# Importation de librairies standards:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline  

# un nouvel import utile pour la 3D:
from matplotlib import cm

# Les instructions suivantes sont TRES utiles pour recharger automatiquement 
# le code modifié dans les librairies externes
%load_ext autoreload
%autoreload 2

# Pour mesurer le temps
import time

# Importation de votre librairie iads:
# La ligne suivante permet de préciser le chemin d'accès à la librairie iads
import sys
sys.path.append('../')   # iads doit être dans le répertoire père du répertoire courant !

# Importation de la librairie iads
import iads as iads

# importation de Classifiers
from iads import Classifiers as classif

# importation de utils
from iads import utils as ut

# importation de evaluation
from iads import evaluation as ev

# importation de Clustering
from iads import Clustering as clust

# commande TRES utile pour recharger automatiquement le code que vous modifiez dans les modules
%load_ext autoreload
%autoreload 2

import math
from scipy.sparse import csr_matrix
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics.pairwise import cosine_distances
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.metrics import silhouette_score
from sklearn.metrics import adjusted_rand_score, normalized_mutual_info_score
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import PCA
import graphviz as gv

The autoreload extension is already loaded. To reload it, use:
  %reload_ext autoreload
The autoreload extension is already loaded. To reload it, use:
  %reload_ext autoreload

newsgroups_df = pd.read_csv("data/20newsgroups.csv")
newsgroups_df

stop_words_df = pd.read_csv("data/stopwords.csv")
stop_words_df

newsgroups_df_neitoie = newsgroups_df.dropna(subset=['messages'])
stop_words_list = stop_words_df['stopword'].tolist()
newsgroups_df_neitoie['les_mots'] = newsgroups_df_neitoie['messages'].apply(lambda x: ut.text2vect(x, stop_words_list))
newsgroups_df_neitoie

/var/folders/x0/9jmwqqtj7s13pdfprxbhp6r00000gn/T/ipykernel_47223/959504396.py:3: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  newsgroups_df_neitoie['les_mots'] = newsgroups_df_neitoie['messages'].apply(lambda x: ut.text2vect(x, stop_words_list))

index_mots = sorted(set(word for mots in newsgroups_df_neitoie['les_mots'] for word in mots))

print("Nombre de mots trouvés: ", len(index_mots))
print("Les 10 premiers :", index_mots[0:10]) 

# pour contrôler:
for i in range(30,len(index_mots),100):
    print("\ten position ",i," --> ", index_mots[i])

Nombre de mots trouvés:  90850
Les 10 premiers : ["''a", "''achzq", "''afduqy", "''afg", "''ai", "''ai''q", "''al", "''bpl", "''bs", "''c"]
	en position  30  -->  'afdzqvg'al
	en position  130  -->  'i'
	en position  230  -->  'qp
	en position  330  -->  'wx
	en position  430  -->  aarskog
	en position  530  -->  abhorrence
	en position  630  -->  abridgement
	en position  730  -->  acadamy
	en position  830  -->  accom
	en position  930  -->  accusers
	en position  1030  -->  acknowledgment
	en position  1130  -->  activitiests
	en position  1230  -->  adda
	en position  1330  -->  aditives
	en position  1430  -->  ado
	en position  1530  -->  adventists
	en position  1630  -->  aerodynamics
	en position  1730  -->  afflicting
	en position  1830  -->  agabus
	en position  1930  -->  agonies
	en position  2030  -->  ahmad
	en position  2130  -->  aire
	en position  2230  -->  ajteel
	en position  2330  -->  alarm
	en position  2430  -->  aleuts
	en position  2530  -->  alive
	en position  2630  -->  allowances
	en position  2730  -->  alsys
	en position  2830  -->  amanda
	en position  2930  -->  amfar
	en position  3030  -->  amphetamines
	en position  3130  -->  analgesics
	en position  3230  -->  anders
	en position  3330  -->  angles
	en position  3430  -->  annihiliation
	en position  3530  -->  anpv
	en position  3630  -->  antidote
	en position  3730  -->  anybodys
	en position  3830  -->  apcut
	en position  3930  -->  appaddinput
	en position  4030  -->  applikation
	en position  4130  -->  approximately
	en position  4230  -->  arabie
	en position  4330  -->  archive
	en position  4430  -->  argv
	en position  4530  -->  armenia
	en position  4630  -->  arraymax
	en position  4730  -->  artifact
	en position  4830  -->  ase
	en position  4930  -->  aspersions
	en position  5030  -->  assign
	en position  5130  -->  astounded
	en position  5230  -->  atary
	en position  5330  -->  atni
	en position  5430  -->  attitute
	en position  5530  -->  auggggg
	en position  5630  -->  authers
	en position  5730  -->  automotive
	en position  5830  -->  aversion
	en position  5930  -->  awfully
	en position  6030  -->  aything
	en position  6130  -->  ba'als
	en position  6230  -->  backlighting
	en position  6330  -->  baf
	en position  6430  -->  baldschun
	en position  6530  -->  bandits
	en position  6630  -->  barbequing
	en position  6730  -->  barrettd
	en position  6830  -->  basicaly
	en position  6930  -->  battleship
	en position  7030  -->  bcg'x
	en position  7130  -->  bearded
	en position  7230  -->  bedouin's
	en position  7330  -->  begzadian
	en position  7430  -->  belies
	en position  7530  -->  bendi
	en position  7630  -->  bereft
	en position  7730  -->  besler
	en position  7830  -->  bfoffbits
	en position  7930  -->  bi'g
	en position  8030  -->  bigmac
	en position  8130  -->  bimidgi
	en position  8230  -->  biotechnet
	en position  8330  -->  bitsy
	en position  8430  -->  blacklists
	en position  8530  -->  ble
	en position  8630  -->  blocks
	en position  8730  -->  blur
	en position  8830  -->  boaring
	en position  8930  -->  boilers
	en position  9030  -->  bonilla's
	en position  9130  -->  bootup
	en position  9230  -->  bosse
	en position  9330  -->  bowers
	en position  9430  -->  brace
	en position  9530  -->  bratt
	en position  9630  -->  breezed
	en position  9730  -->  brighter
	en position  9830  -->  broken
	en position  9930  -->  brulliance
	en position  10030  -->  btw
	en position  10130  -->  buffeting
	en position  10230  -->  bullied
	en position  10330  -->  bure's
	en position  10430  -->  buses
	en position  10530  -->  bux
	en position  10630  -->  bymmr
	en position  10730  -->  cabinetmaker
	en position  10830  -->  calander
	en position  10930  -->  callsign
	en position  11030  -->  campollo
	en position  11130  -->  cannon
	en position  11230  -->  capped
	en position  11330  -->  cardfile
	en position  11430  -->  caroline
	en position  11530  -->  case
	en position  11630  -->  catcat
	en position  11730  -->  cavallini
	en position  11830  -->  ccelum
	en position  11930  -->  ceasing
	en position  12030  -->  census
	en position  12130  -->  cert
	en position  12230  -->  cgin
	en position  12330  -->  championships
	en position  12430  -->  charged
	en position  12530  -->  cheapish
	en position  12630  -->  cheney
	en position  12730  -->  chigger
	en position  12830  -->  chistmas
	en position  12930  -->  chow
	en position  13030  -->  chronological
	en position  13130  -->  ciau
	en position  13230  -->  circ
	en position  13330  -->  citr
	en position  13430  -->  clam
	en position  13530  -->  clay
	en position  13630  -->  clia
	en position  13730  -->  clling
	en position  13830  -->  clumsy
	en position  13930  -->  cnql
	en position  14030  -->  cocktails
	en position  14130  -->  coiled
	en position  14230  -->  collectors
	en position  14330  -->  colortable
	en position  14430  -->  comet
	en position  14530  -->  commericalization
	en position  14630  -->  community's
	en position  14730  -->  compete
	en position  14830  -->  composed
	en position  14930  -->  computerist
	en position  15030  -->  concise
	en position  15130  -->  conductor
	en position  15230  -->  conforming
	en position  15330  -->  conklin
	en position  15430  -->  consent
	en position  15530  -->  constable
	en position  15630  -->  contacting
	en position  15730  -->  contool
	en position  15830  -->  conuntry
	en position  15930  -->  cook
	en position  16030  -->  coprocessors
	en position  16130  -->  cornering
	en position  16230  -->  corse
	en position  16330  -->  coul
	en position  16430  -->  courageous
	en position  16530  -->  cowl
	en position  16630  -->  craetveld
	en position  16730  -->  creased
	en position  16830  -->  criminalization
	en position  16930  -->  crock
	en position  17030  -->  crres
	en position  17130  -->  cryptanalysis
	en position  17230  -->  csri
	en position  17330  -->  cuddles
	en position  17430  -->  curcio
	en position  17530  -->  cutaway
	en position  17630  -->  cxtgcxwocxxi
	en position  17730  -->  cyprian
	en position  17830  -->  dabro
	en position  17930  -->  daly
	en position  18030  -->  dante
	en position  18130  -->  dastar
	en position  18230  -->  davidsson's
	en position  18330  -->  dcdmwm
	en position  18430  -->  deals
	en position  18530  -->  deceitfulness
	en position  18630  -->  decompose
	en position  18730  -->  deducible
	en position  18830  -->  defensible
	en position  18930  -->  defused
	en position  19030  -->  delegate
	en position  19130  -->  delve
	en position  19230  -->  demosrc
	en position  19330  -->  deny
	en position  19430  -->  depresses
	en position  19530  -->  desciption
	en position  19630  -->  desnoyers
	en position  19730  -->  detaining
	en position  19830  -->  deuterocanonical
	en position  19930  -->  dew
	en position  20030  -->  di
	en position  20130  -->  dick
	en position  20230  -->  differ
	en position  20330  -->  diku
	en position  20430  -->  diocese
	en position  20530  -->  dis
	en position  20630  -->  discharged
	en position  20730  -->  discriminated
	en position  20830  -->  disire
	en position  20930  -->  dispelling
	en position  21030  -->  dissapated
	en position  21130  -->  distributer
	en position  21230  -->  division's
	en position  21330  -->  dli
	en position  21430  -->  docialists
	en position  21530  -->  dogskin
	en position  21630  -->  donestr
	en position  21730  -->  dos
	en position  21830  -->  downlink
	en position  21930  -->  draft
	en position  22030  -->  dremel
	en position  22130  -->  drosophila
	en position  22230  -->  dss
	en position  22330  -->  dudley
	en position  22430  -->  dunn
	en position  22530  -->  dvhz
	en position  22630  -->  dylan
	en position  22730  -->  earliest
	en position  22830  -->  eberle
	en position  22930  -->  ecnet
	en position  23030  -->  edited
	en position  23130  -->  eerie
	en position  23230  -->  egg
	en position  23330  -->  eighth
	en position  23430  -->  elaborates
	en position  23530  -->  electrophotography
	en position  23630  -->  ellernstr
	en position  23730  -->  emailed
	en position  23830  -->  emersing
	en position  23930  -->  empirically
	en position  24030  -->  enchanter
	en position  24130  -->  endeth
	en position  24230  -->  engine's
	en position  24330  -->  enrich
	en position  24430  -->  entranced
	en position  24530  -->  eo
	en position  24630  -->  eprom
	en position  24730  -->  eradicators
	en position  24830  -->  eroticism
	en position  24930  -->  escherknot
	en position  25030  -->  essensa
	en position  25130  -->  etherfind
	en position  25230  -->  euh
	en position  25330  -->  evangelist
	en position  25430  -->  evident
	en position  25530  -->  exactly
	en position  25630  -->  exchanger
	en position  25730  -->  exempting
	en position  25830  -->  exothermic
	en position  25930  -->  expiration
	en position  26030  -->  expressway
	en position  26130  -->  extravaganza
	en position  26230  -->  ezqiv
	en position  26330  -->  factorization
	en position  26430  -->  faithlessly
	en position  26530  -->  fan's
	en position  26630  -->  farringdon
	en position  26730  -->  faulkt
	en position  26830  -->  fcv
	en position  26930  -->  federation
	en position  27030  -->  felsner
	en position  27130  -->  fertilization
	en position  27230  -->  fgj
	en position  27330  -->  fields
	en position  27430  -->  fileserver
	en position  27530  -->  fingers
	en position  27630  -->  firsthand
	en position  27730  -->  fjp
	en position  27830  -->  flashlight
	en position  27930  -->  flibozity
	en position  28030  -->  florescent
	en position  28130  -->  fm
	en position  28230  -->  foiidfkx
	en position  28330  -->  fools
	en position  28430  -->  foremost
	en position  28530  -->  formicinae
	en position  28630  -->  fossils
	en position  28730  -->  fpus
	en position  28830  -->  francisco
	en position  28930  -->  freemasons
	en position  29030  -->  fries
	en position  29130  -->  frr
	en position  29230  -->  ftpmail
	en position  29330  -->  fullness
	en position  29430  -->  furleys
	en position  29530  -->  fwmr
	en position  29630  -->  g'ors
	en position  29730  -->  galiatsato
	en position  29830  -->  gangbusters
	en position  29930  -->  gartner
	en position  30030  -->  gauss
	en position  30130  -->  gcw
	en position  30230  -->  gelegenheid
	en position  30330  -->  genlock
	en position  30430  -->  geos
	en position  30530  -->  gets
	en position  30630  -->  ghq
	en position  30730  -->  gillow
	en position  30830  -->  giyx
	en position  30930  -->  glavkosmos
	en position  31030  -->  glow
	en position  31130  -->  gnu
	en position  31230  -->  goggleless
	en position  31330  -->  good
	en position  31430  -->  goto
	en position  31530  -->  gpyz
	en position  31630  -->  grammi
	en position  31730  -->  grassy
	en position  31830  -->  green's
	en position  31930  -->  grieved
	en position  32030  -->  groping
	en position  32130  -->  grungy
	en position  32230  -->  guardrail
	en position  32330  -->  gulped
	en position  32430  -->  gushed
	en position  32530  -->  gxs
	en position  32630  -->  haalbaarheid
	en position  32730  -->  hagen
	en position  32830  -->  halderc
	en position  32930  -->  hamlin
	en position  33030  -->  handout
	en position  33130  -->  harassment
	en position  33230  -->  harleys
	en position  33330  -->  hasanali
	en position  33430  -->  haunts
	en position  33530  -->  hbpeltz
	en position  33630  -->  headspace
	en position  33730  -->  heb
	en position  33830  -->  heinous
	en position  33930  -->  helps
	en position  34030  -->  herbison
	en position  34130  -->  herzegovine
	en position  34230  -->  hfpah
	en position  34330  -->  hierarchical
	en position  34430  -->  himem
	en position  34530  -->  hiss
	en position  34630  -->  hkcxxkc
	en position  34730  -->  hob
	en position  34830  -->  hole
	en position  34930  -->  homesick
	en position  35030  -->  hoodwink
	en position  35130  -->  horrified
	en position  35230  -->  houda
	en position  35330  -->  hphcd
	en position  35430  -->  hsczllqc
	en position  35530  -->  hugging
	en position  35630  -->  hundread
	en position  35730  -->  huusr
	en position  35830  -->  hydroxyl
	en position  35930  -->  hypoxemia
	en position  36030  -->  iaa
	en position  36130  -->  ic's
	en position  36230  -->  idaho
	en position  36330  -->  idraw's
	en position  36430  -->  ignitions
	en position  36530  -->  iipa
	en position  36630  -->  ilitch
	en position  36730  -->  imagewidth
	en position  36830  -->  immmense
	en position  36930  -->  impedes
	en position  37030  -->  importation
	en position  37130  -->  imrlk
	en position  37230  -->  incestual
	en position  37330  -->  inconveniently
	en position  37430  -->  independance
	en position  37530  -->  indonesie
	en position  37630  -->  inexperienced
	en position  37730  -->  inflateble
	en position  37830  -->  ingerle
	en position  37930  -->  initializes
	en position  38030  -->  innovators
	en position  38130  -->  insemination
	en position  38230  -->  instdatflags
	en position  38330  -->  insusceptible
	en position  38430  -->  interative
	en position  38530  -->  interleaved
	en position  38630  -->  interrupt
	en position  38730  -->  intrepid
	en position  38830  -->  inverted
	en position  38930  -->  iorating
	en position  39030  -->  irag
	en position  39130  -->  irregardless
	en position  39230  -->  ish
	en position  39330  -->  ispfmt
	en position  39430  -->  itch
	en position  39530  -->  ivc
	en position  39630  -->  izi
	en position  39730  -->  jaffe
	en position  39830  -->  japlish
	en position  39930  -->  jce
	en position  40030  -->  jelloman
	en position  40130  -->  jewel
	en position  40230  -->  jiggled
	en position  40330  -->  jjjkiz
	en position  40430  -->  job
	en position  40530  -->  jolted
	en position  40630  -->  joyous
	en position  40730  -->  jscotti
	en position  40830  -->  judizers
	en position  40930  -->  jur
	en position  41030  -->  jwo
	en position  41130  -->  k's
	en position  41230  -->  kamieniecki
	en position  41330  -->  karl
	en position  41430  -->  kaukasier
	en position  41530  -->  kdl
	en position  41630  -->  kempf
	en position  41730  -->  kettle
	en position  41830  -->  kfss
	en position  41930  -->  khojali
	en position  42030  -->  kilcore
	en position  42130  -->  kingsley's
	en position  42230  -->  kjbis
	en position  42330  -->  kleer
	en position  42430  -->  knickle
	en position  42530  -->  kocz
	en position  42630  -->  kookiness
	en position  42730  -->  koylerine
	en position  42830  -->  kriger
	en position  42930  -->  kte
	en position  43030  -->  kurtaran
	en position  43130  -->  kyrm
	en position  43230  -->  laced
	en position  43330  -->  lakshman
	en position  43430  -->  lanes
	en position  43530  -->  larly
	en position  43630  -->  lattices
	en position  43730  -->  laxemburg
	en position  43830  -->  ldevy
	en position  43930  -->  least
	en position  44030  -->  lefts
	en position  44130  -->  leland
	en position  44230  -->  lerosse
	en position  44330  -->  levinson
	en position  44430  -->  lh's
	en position  44530  -->  libertopian
	en position  44630  -->  liechenstein
	en position  44730  -->  liking
	en position  44830  -->  linedraw
	en position  44930  -->  liquid
	en position  45030  -->  litterbox
	en position  45130  -->  lkwj
	en position  45230  -->  lobbed
	en position  45330  -->  logic
	en position  45430  -->  looker
	en position  45530  -->  lot
	en position  45630  -->  lpd
	en position  45730  -->  lsmrn
	en position  45830  -->  lugged
	en position  45930  -->  luser
	en position  46030  -->  lxmu
	en position  46130  -->  lzn
	en position  46230  -->  macaulay
	en position  46330  -->  mackie's
	en position  46430  -->  maddison
	en position  46530  -->  magnetosphere
	en position  46630  -->  mailstop
	en position  46730  -->  maketheirday
	en position  46830  -->  malmoe
	en position  46930  -->  mandell
	en position  47030  -->  manouver
	en position  47130  -->  marb
	en position  47230  -->  marke
	en position  47330  -->  marsolais
	en position  47430  -->  massachussetts
	en position  47530  -->  mathematique
	en position  47630  -->  mauro
	en position  47730  -->  mazinkert
	en position  47830  -->  mccarthy's
	en position  47930  -->  mchlb
	en position  48030  -->  mcu
	en position  48130  -->  meanwhile
	en position  48230  -->  mediated
	en position  48330  -->  megaman
	en position  48430  -->  mellows
	en position  48530  -->  meningococcus
	en position  48630  -->  merk
	en position  48730  -->  metabolizes
	en position  48830  -->  metropolis
	en position  48930  -->  mfx'u
	en position  49030  -->  mhsd
	en position  49130  -->  microdevices
	en position  49230  -->  midas
	en position  49330  -->  mikhailovich
	en position  49430  -->  milliwatts
	en position  49530  -->  minimizing
	en position  49630  -->  miri
	en position  49730  -->  misinterpret
	en position  49830  -->  mistated
	en position  49930  -->  mize's
	en position  50030  -->  mko
	en position  50130  -->  mmd'k
	en position  50230  -->  mnkirnah
	en position  50330  -->  moderation
	en position  50430  -->  moir
	en position  50530  -->  monastery
	en position  50630  -->  monotomic
	en position  50730  -->  mops
	en position  50830  -->  morse
	en position  50930  -->  motif's
	en position  51030  -->  mous
	en position  51130  -->  mpkjao
	en position  51230  -->  mqxt
	en position  51330  -->  ms'lc
	en position  51430  -->  mtkgc
	en position  51530  -->  muftus
	en position  51630  -->  multiple
	en position  51730  -->  municipal
	en position  51830  -->  musician
	en position  51930  -->  mva
	en position  52030  -->  mwwwp
	en position  52130  -->  mylex
	en position  52230  -->  mzuo
	en position  52330  -->  nail
	en position  52430  -->  naproxen
	en position  52530  -->  nationalteam
	en position  52630  -->  nazr
	en position  52730  -->  ne'onatal
	en position  52830  -->  needlesused
	en position  52930  -->  neither
	en position  53030  -->  netanyahu
	en position  53130  -->  neuropharmacology
	en position  53230  -->  newington
	en position  53330  -->  nextsetlasteventtime
	en position  53430  -->  nhtsa
	en position  53530  -->  nielson
	en position  53630  -->  ninjakun
	en position  53730  -->  nka
	en position  53830  -->  nmsca
	en position  53930  -->  noiseless
	en position  54030  -->  nono
	en position  54130  -->  norm
	en position  54230  -->  notesgroup
	en position  54330  -->  np
	en position  54430  -->  nsfgr
	en position  54530  -->  nuisances
	en position  54630  -->  nutshell
	en position  54730  -->  nylanders
	en position  54830  -->  o'yre
	en position  54930  -->  obg
	en position  55030  -->  observtions
	en position  55130  -->  occurrence
	en position  55230  -->  odishelidje
	en position  55330  -->  officials
	en position  55430  -->  ohmigod
	en position  55530  -->  ol
	en position  55630  -->  olvr
	en position  55730  -->  oncs
	en position  55830  -->  oooh
	en position  55930  -->  ophthalmol
	en position  56030  -->  optimism
	en position  56130  -->  oratory
	en position  56230  -->  organised
	en position  56330  -->  orlii
	en position  56430  -->  osco
	en position  56530  -->  othello
	en position  56630  -->  outcompete
	en position  56730  -->  outshooting
	en position  56830  -->  overgrazed
	en position  56930  -->  overshadowed
	en position  57030  -->  owg
	en position  57130  -->  ozh
	en position  57230  -->  paderborner
	en position  57330  -->  pajz
	en position  57430  -->  pancreas
	en position  57530  -->  papresco
	en position  57630  -->  paratroops
	en position  57730  -->  parrotting
	en position  57830  -->  pasha
	en position  57930  -->  patches
	en position  58030  -->  patton
	en position  58130  -->  pbq
	en position  58230  -->  peaceably
	en position  58330  -->  peeing
	en position  58430  -->  penely
	en position  58530  -->  perakende
	en position  58630  -->  perilous
	en position  58730  -->  perplexed
	en position  58830  -->  pertain
	en position  58930  -->  petterson
	en position  59030  -->  pgvznazz
	en position  59130  -->  philbrick's
	en position  59230  -->  phoosball
	en position  59330  -->  physical
	en position  59430  -->  pieces
	en position  59530  -->  pilon's
	en position  59630  -->  pirates
	en position  59730  -->  pixt
	en position  59830  -->  plainext
	en position  59930  -->  platters
	en position  60030  -->  pliable
	en position  60130  -->  pluto
	en position  60230  -->  pobox
	en position  60330  -->  polaris
	en position  60430  -->  polycontrast
	en position  60530  -->  poor
	en position  60630  -->  portion
	en position  60730  -->  postdiarrheal
	en position  60830  -->  pound
	en position  60930  -->  ppi
	en position  61030  -->  prating
	en position  61130  -->  precompiled
	en position  61230  -->  preferences
	en position  61330  -->  preponderance
	en position  61430  -->  pressman
	en position  61530  -->  prf
	en position  61630  -->  printing
	en position  61730  -->  prober
	en position  61830  -->  productions
	en position  61930  -->  progresslively
	en position  62030  -->  pronation
	en position  62130  -->  proportional
	en position  62230  -->  protections
	en position  62330  -->  provocative
	en position  62430  -->  psinet
	en position  62530  -->  ptfe
	en position  62630  -->  puffy
	en position  62730  -->  punk
	en position  62830  -->  pursues
	en position  62930  -->  pwoodcoc
	en position  63030  -->  qalui
	en position  63130  -->  qgluje
	en position  63230  -->  qmecp
	en position  63330  -->  qro
	en position  63430  -->  quadrinomials
	en position  63530  -->  quarterfinals
	en position  63630  -->  quickkeys
	en position  63730  -->  qur'an
	en position  63830  -->  qzdj
	en position  63930  -->  radiators
	en position  64030  -->  railrays
	en position  64130  -->  ramps
	en position  64230  -->  rapsheet
	en position  64330  -->  rations
	en position  64430  -->  rbecs
	en position  64530  -->  rdg
	en position  64630  -->  realistic
	en position  64730  -->  reb
	en position  64830  -->  recent
	en position  64930  -->  recomendations
	en position  65030  -->  recurrance
	en position  65130  -->  reducible
	en position  65230  -->  refinance
	en position  65330  -->  regaining
	en position  65430  -->  regulated
	en position  65530  -->  reintroduced
	en position  65630  -->  relegates
	en position  65730  -->  remain
	en position  65830  -->  renal
	en position  65930  -->  repairmen
	en position  66030  -->  reponse
	en position  66130  -->  repulsion
	en position  66230  -->  resepct
	en position  66330  -->  resonators
	en position  66430  -->  restating
	en position  66530  -->  retentive
	en position  66630  -->  reuse
	en position  66730  -->  revolted
	en position  66830  -->  rgan
	en position  66930  -->  rica
	en position  67030  -->  rifts
	en position  67130  -->  rioting
	en position  67230  -->  rjf'
	en position  67330  -->  rlojsqk
	en position  67430  -->  roadblocks
	en position  67530  -->  rocked
	en position  67630  -->  rolexen
	en position  67730  -->  rootwindow
	en position  67830  -->  rotting
	en position  67930  -->  rpai
	en position  68030  -->  rsk
	en position  68130  -->  rudeness
	en position  68230  -->  runway
	en position  68330  -->  rvoj'
	en position  68430  -->  ryza
	en position  68530  -->  sack
	en position  68630  -->  safhada
	en position  68730  -->  salient
	en position  68830  -->  sampo
	en position  68930  -->  sankar
	en position  69030  -->  satan
	en position  69130  -->  save's
	en position  69230  -->  scale
	en position  69330  -->  scdrye
	en position  69430  -->  schizophrenia
	en position  69530  -->  schwan
	en position  69630  -->  scorebook
	en position  69730  -->  screenplay
	en position  69830  -->  scuffed
	en position  69930  -->  sean
	en position  70030  -->  secretariat
	en position  70130  -->  seens
	en position  70230  -->  seleucids
	en position  70330  -->  sences
	en position  70430  -->  seperates
	en position  70530  -->  serotonin
	en position  70630  -->  setwutime
	en position  70730  -->  sgfi
	en position  70830  -->  shamed
	en position  70930  -->  shayne
	en position  71030  -->  sheridan
	en position  71130  -->  shirazi
	en position  71230  -->  shorm
	en position  71330  -->  shred
	en position  71430  -->  shzrchorci
	en position  71530  -->  siegert
	en position  71630  -->  sigpipe
	en position  71730  -->  simlist
	en position  71830  -->  sineva
	en position  71930  -->  sisters
	en position  72030  -->  ska
	en position  72130  -->  skirts
	en position  72230  -->  slanted
	en position  72330  -->  sliders
	en position  72430  -->  slowly
	en position  72530  -->  smatterings
	en position  72630  -->  smr'wg
	en position  72730  -->  snif
	en position  72830  -->  sobering
	en position  72930  -->  softlanding
	en position  73030  -->  solomon
	en position  73130  -->  sonically
	en position  73230  -->  soton
	en position  73330  -->  sowetos
	en position  73430  -->  sparc
	en position  73530  -->  specialties
	en position  73630  -->  speek
	en position  73730  -->  spinach
	en position  73830  -->  spokespeople
	en position  73930  -->  spped
	en position  74030  -->  sqa
	en position  74130  -->  sqx
	en position  74230  -->  ssns
	en position  74330  -->  staircase
	en position  74430  -->  stapleton
	en position  74530  -->  staticgray
	en position  74630  -->  steed
	en position  74730  -->  stepwise
	en position  74830  -->  stiehm
	en position  74930  -->  stocking
	en position  75030  -->  storeys
	en position  75130  -->  strategists
	en position  75230  -->  stricted
	en position  75330  -->  sts'lm
	en position  75430  -->  styling
	en position  75530  -->  sublette
	en position  75630  -->  subsonic
	en position  75730  -->  successors
	en position  75830  -->  suggestion
	en position  75930  -->  summerall
	en position  76030  -->  sununu
	en position  76130  -->  superscape
	en position  76230  -->  supprise
	en position  76330  -->  surrogate
	en position  76430  -->  suu
	en position  76530  -->  swastikas
	en position  76630  -->  swiped
	en position  76730  -->  syk
	en position  76830  -->  syndicate
	en position  76930  -->  systen
	en position  77030  -->  tachycardia
	en position  77130  -->  takeover
	en position  77230  -->  tandem
	en position  77330  -->  tarih
	en position  77430  -->  taurid
	en position  77530  -->  tcy
	en position  77630  -->  techpubs
	en position  77730  -->  telefunken
	en position  77830  -->  templevm
	en position  77930  -->  teperman
	en position  78030  -->  terror
	en position  78130  -->  texel
	en position  78230  -->  thankful
	en position  78330  -->  themsselves
	en position  78430  -->  thermogenic
	en position  78530  -->  thinner
	en position  78630  -->  thousands
	en position  78730  -->  thshn
	en position  78830  -->  tib
	en position  78930  -->  tikht
	en position  79030  -->  tinges
	en position  79130  -->  tj
	en position  79230  -->  tnd
	en position  79330  -->  tokelau
	en position  79430  -->  tony
	en position  79530  -->  toricelli's
	en position  79630  -->  totem
	en position  79730  -->  toxic
	en position  79830  -->  tractors
	en position  79930  -->  trannys
	en position  80030  -->  transjordan
	en position  80130  -->  trapping
	en position  80230  -->  trei
	en position  80330  -->  tried
	en position  80430  -->  triumvirate
	en position  80530  -->  truecolor
	en position  80630  -->  tsj
	en position  80730  -->  tudjman
	en position  80830  -->  turbomodem
	en position  80930  -->  tutxp
	en position  81030  -->  twinsun
	en position  81130  -->  typist
	en position  81230  -->  uartdata
	en position  81330  -->  udh
	en position  81430  -->  uhn
	en position  81530  -->  ulcers
	en position  81630  -->  umped
	en position  81730  -->  unbaptist
	en position  81830  -->  uncompressed
	en position  81930  -->  undercurrent
	en position  82030  -->  undertook
	en position  82130  -->  unexpected
	en position  82230  -->  unhookable
	en position  82330  -->  unistd
	en position  82430  -->  unlikly
	en position  82530  -->  unpersuasive
	en position  82630  -->  uns
	en position  82730  -->  unsuspecting
	en position  82830  -->  unworthy
	en position  82930  -->  uplinked
	en position  83030  -->  urbana
	en position  83130  -->  usefull
	en position  83230  -->  usualy
	en position  83330  -->  utterances
	en position  83430  -->  uxsd
	en position  83530  -->  vagaries
	en position  83630  -->  vanbiesbrouck's
	en position  83730  -->  varis
	en position  83830  -->  vbe
	en position  83930  -->  vedio
	en position  84030  -->  venetians
	en position  84130  -->  verions
	en position  84230  -->  vestnik
	en position  84330  -->  vibrator
	en position  84430  -->  viewdvi
	en position  84530  -->  vinnaren
	en position  84630  -->  visitation
	en position  84730  -->  vlad
	en position  84830  -->  vociferously
	en position  84930  -->  volvo's
	en position  85030  -->  vqr
	en position  85130  -->  vukela
	en position  85230  -->  vyjx
	en position  85330  -->  wage
	en position  85430  -->  wallets
	en position  85530  -->  warehousemen
	en position  85630  -->  wast
	en position  85730  -->  waxed
	en position  85830  -->  we'er
	en position  85930  -->  weeker
	en position  86030  -->  wellllll
	en position  86130  -->  wether
	en position  86230  -->  whcih
	en position  86330  -->  whirrr
	en position  86430  -->  whooped
	en position  86530  -->  wiersema
	en position  86630  -->  wilma
	en position  86730  -->  wingz
	en position  86830  -->  wiretapping
	en position  86930  -->  wixer
	en position  87030  -->  wnkretz
	en position  87130  -->  wondrously
	en position  87230  -->  workmanship
	en position  87330  -->  wove
	en position  87430  -->  wright
	en position  87530  -->  wtih
	en position  87630  -->  wwr
	en position  87730  -->  xanadu
	en position  87830  -->  xclrs
	en position  87930  -->  xdum
	en position  88030  -->  xgetmodifiermapping
	en position  88130  -->  ximagehandler
	en position  88230  -->  xlnth
	en position  88330  -->  xmptablemakecolsfitquerywidth
	en position  88430  -->  xpermits
	en position  88530  -->  xrlogind
	en position  88630  -->  xssr
	en position  88730  -->  xtdestructor
	en position  88830  -->  xtnargc
	en position  88930  -->  xtsetvalues
	en position  89030  -->  xvl
	en position  89130  -->  xxxxdraft
	en position  89230  -->  yale
	en position  89330  -->  yax
	en position  89430  -->  yell
	en position  89530  -->  yielded
	en position  89630  -->  ymp
	en position  89730  -->  youngster's
	en position  89830  -->  ytf
	en position  89930  -->  ywvv
	en position  90030  -->  zaire
	en position  90130  -->  zcjjj
	en position  90230  -->  zeta
	en position  90330  -->  zimmermann
	en position  90430  -->  zlp
	en position  90530  -->  zodiacal
	en position  90630  -->  zqww
	en position  90730  -->  zumw
	en position  90830  -->  zyv

# Importation des bibliothèques nécessaires
from collections import Counter  # Pour compter les occurrences de mots
import nltk  # Natural Language Toolkit
from nltk.corpus import words  # Vocabulaire anglais de NLTK

# Téléchargement du vocabulaire anglais depuis NLTK
nltk.download('words')

# Création d'un ensemble du vocabulaire anglais pour vérification rapide
english_vocab = set(words.words())

# Extraction de tous les mots du DataFrame (aplatissement de la liste de listes)
all_words = [word for mots in newsgroups_df_neitoie['les_mots'] for word in mots]

# Comptage des occurrences de chaque mot
word_counts = Counter(all_words)

# Création d'un index de mots filtrés selon plusieurs critères:
index_mots = sorted(set(
    mot for mot in all_words
    if mot[0].isalpha()  # Le mot commence par une lettre
    and mot.isalpha()  # Le mot ne contient que des lettres
    and 3 <= len(mot) <= 20  # Longueur entre 3 et 20 caractères
    and word_counts[mot] >= 5  # Apparaît au moins 5 fois
    and mot.lower() in english_vocab  # Fait partie du vocabulaire anglais
))

# Affichage des statistiques
print("Nombre de mots trouvés: ", len(index_mots))
print("Les 10 premiers :", index_mots[0:10]) 

# Vérification aléatoire de la qualité des résultats
for i in range(30, len(index_mots), 100):  # Par pas de 100 à partir de l'index 30
    print("\ten position ", i, " --> ", index_mots[i])

[nltk_data] Downloading package words to
[nltk_data]     /Users/yuxiangzhang/nltk_data...
[nltk_data]   Package words is already up-to-date!

Nombre de mots trouvés:  11928
Les 10 premiers : ['abandon', 'abandoned', 'abbey', 'abbreviation', 'abdomen', 'abdominal', 'abduct', 'aberrant', 'aberration', 'abhor']
	en position  30  -->  absolute
	en position  130  -->  acupuncture
	en position  230  -->  aftermath
	en position  330  -->  alpine
	en position  430  -->  angular
	en position  530  -->  applicant
	en position  630  -->  ashamed
	en position  730  -->  attractive
	en position  830  -->  bacterium
	en position  930  -->  batting
	en position  1030  -->  betting
	en position  1130  -->  blink
	en position  1230  -->  bound
	en position  1330  -->  brutal
	en position  1430  -->  cain
	en position  1530  -->  carry
	en position  1630  -->  chalk
	en position  1730  -->  choleric
	en position  1830  -->  click
	en position  1930  -->  collapse
	en position  2030  -->  compatible
	en position  2130  -->  condensed
	en position  2230  -->  conspiracy
	en position  2330  -->  convinced
	en position  2430  -->  coupon
	en position  2530  -->  cruel
	en position  2630  -->  damnation
	en position  2730  -->  deductive
	en position  2830  -->  dental
	en position  2930  -->  deviant
	en position  3030  -->  directly
	en position  3130  -->  disposition
	en position  3230  -->  doll
	en position  3330  -->  droplet
	en position  3430  -->  ecstatic
	en position  3530  -->  emotional
	en position  3630  -->  enthusiasm
	en position  3730  -->  ethnical
	en position  3830  -->  exhibition
	en position  3930  -->  fabrication
	en position  4030  -->  feared
	en position  4130  -->  find
	en position  4230  -->  flung
	en position  4330  -->  fortunate
	en position  4430  -->  functionality
	en position  4530  -->  generation
	en position  4630  -->  godhead
	en position  4730  -->  grill
	en position  4830  -->  hander
	en position  4930  -->  hearts
	en position  5030  -->  hobgoblin
	en position  5130  -->  humane
	en position  5230  -->  imagination
	en position  5330  -->  incidental
	en position  5430  -->  infected
	en position  5530  -->  insinuating
	en position  5630  -->  intern
	en position  5730  -->  irrational
	en position  5830  -->  jury
	en position  5930  -->  lamp
	en position  6030  -->  legality
	en position  6130  -->  liner
	en position  6230  -->  lose
	en position  6330  -->  male
	en position  6430  -->  mater
	en position  6530  -->  meshed
	en position  6630  -->  miracle
	en position  6730  -->  monogamous
	en position  6830  -->  mun
	en position  6930  -->  needing
	en position  7030  -->  nonsense
	en position  7130  -->  observing
	en position  7230  -->  oppose
	en position  7330  -->  oval
	en position  7430  -->  paperback
	en position  7530  -->  pause
	en position  7630  -->  perspective
	en position  7730  -->  pipe
	en position  7830  -->  poisoning
	en position  7930  -->  pounding
	en position  8030  -->  pretended
	en position  8130  -->  progressive
	en position  8230  -->  provoking
	en position  8330  -->  queer
	en position  8430  -->  rare
	en position  8530  -->  recommendation
	en position  8630  -->  registered
	en position  8730  -->  repeal
	en position  8830  -->  respondent
	en position  8930  -->  rick
	en position  9030  -->  round
	en position  9130  -->  sang
	en position  9230  -->  scratching
	en position  9330  -->  sence
	en position  9430  -->  shark
	en position  9530  -->  sidewalk
	en position  9630  -->  skin
	en position  9730  -->  snide
	en position  9830  -->  southeast
	en position  9930  -->  spoiled
	en position  10030  -->  statistically
	en position  10130  -->  stratospheric
	en position  10230  -->  substantiate
	en position  10330  -->  supposing
	en position  10430  -->  sync
	en position  10530  -->  technical
	en position  10630  -->  thats
	en position  10730  -->  tic
	en position  10830  -->  totalitarian
	en position  10930  -->  treason
	en position  11030  -->  turbines
	en position  11130  -->  unconnected
	en position  11230  -->  unleaded
	en position  11330  -->  upward
	en position  11430  -->  vent
	en position  11530  -->  vodka
	en position  11630  -->  watched
	en position  11730  -->  wholesale
	en position  11830  -->  working

def bag_of_words_sparse_manual(texts_tokenized, vocab, mode="count"):
    """
    :param mode: valeurs possibles : 'count', 'binary', 'freq'
    """
    vocab_index = {word: i for i, word in enumerate(vocab)}

    rows, cols, data = [], [], []

    for row_idx, tokens in enumerate(texts_tokenized):
        word_counts = {}
        for word in tokens:
            if word in vocab_index:
                col_idx = vocab_index[word]
                word_counts[col_idx] = word_counts.get(col_idx, 0) + 1

        total_words = sum(word_counts.values())

        for col_idx, count in word_counts.items():
            rows.append(row_idx)
            cols.append(col_idx)

            if mode == "count":
                value = count
            elif mode == "binary":
                value = 1
            elif mode == "freq":
                value = count / total_words
            else:
                raise ValueError("Mode non supporté : choisissez parmi 'count', 'binary', 'freq'")

            data.append(value)

    n_rows = len(texts_tokenized)
    n_cols = len(vocab)
    
    sparse_matrix = csr_matrix((data, (rows, cols)), shape=(n_rows, n_cols), dtype=float)
    return sparse_matrix, vocab_index

def bag_of_words_tfidf_manual(textes_tokenisés, vocabulaire):
    """
    :param textes_tokenisés: Liste de listes de mots (tokens)
    :param vocabulaire: liste des mots du vocabulaire
    :return: matrice creuse TF-IDF (csr_matrix), dictionnaire {mot: index}
    """
    vocab_index = {mot: i for i, mot in enumerate(vocabulaire)}
    N_docs = len(textes_tokenisés)  # Nombre de documents
    
    # 1. Calcul de la DF (Document Frequency)
    df_counts = np.zeros(len(vocabulaire))
    for tokens in textes_tokenisés:
        mots_uniques = set(tokens)
        for mot in mots_uniques:
            if mot in vocab_index:
                df_counts[vocab_index[mot]] += 1
    
    # Éviter la division par 0
    df_counts[df_counts == 0] = 1

    # 2. Construction de la matrice creuse TF-IDF
    lignes, colonnes, données = [], [], []

    for doc_idx, tokens in enumerate(textes_tokenisés):
        tf_counts = {}
        for mot in tokens:
            if mot in vocab_index:
                idx = vocab_index[mot]
                tf_counts[idx] = tf_counts.get(idx, 0) + 1

        total_mots = sum(tf_counts.values())

        for idx, tf in tf_counts.items():
            tf_val = tf / total_mots
            idf_val = math.log(N_docs / df_counts[idx])
            tfidf = tf_val * idf_val

            lignes.append(doc_idx)
            colonnes.append(idx)
            données.append(tfidf)

    mat = csr_matrix((données, (lignes, colonnes)), shape=(N_docs, len(vocabulaire)))
    return mat, vocab_index

# Appel de la fonction pour générer la matrice BoW
X_sparse, vec = bag_of_words_sparse_manual(newsgroups_df_neitoie['les_mots'], index_mots)

# Vérification de la forme de la matrice
print(X_sparse.shape)
print(type(X_sparse))

# Conversion en DataFrame pour affichage
df_bow = pd.DataFrame(X_sparse.toarray(), columns=index_mots)
df_bow

(18466, 11928)
<class 'scipy.sparse._csr.csr_matrix'>

np.random.seed(42)  # Pour reproductibilité

# Pourcentage d'exemples de chaque classe à garder :
taux = 0.1  # 10%

# Déclaration des variables qui seront initialisées dans la boucle :
df_train = pd.DataFrame()  
df_test = pd.DataFrame()

les_targets = newsgroups_df_neitoie['target'].unique()

for l in les_targets:
    nb_total = newsgroups_df_neitoie['target'].value_counts()[l]  # Nombre total d'exemples pour la classe l
    nb_pris = int(nb_total * taux)  # Nombre d'exemples à prendre pour l'entraînement
    print(f"Nombre d'exemples du label {l} pris pour apprendre: {nb_pris}")

    # Récupération des indices des exemples de cette classe
    les_ids = newsgroups_df_neitoie[newsgroups_df_neitoie['target'] == l].index.to_list()
    
    # Mélanger les indices aléatoirement
    np.random.shuffle(les_ids)

    # Séparer les indices pour l'entraînement et le test
    ids_train = les_ids[:nb_pris]  # 10% pour l'entraînement
    ids_test = les_ids[nb_pris:]   # Le reste pour le test

    # Ajouter les données correspondantes aux DataFrames
    df_train = pd.concat([df_train, newsgroups_df_neitoie.loc[ids_train]], ignore_index=True)
    df_test = pd.concat([df_test, newsgroups_df_neitoie.loc[ids_test]], ignore_index=True)

# Résultat :
print(f"Dimension de df_train:\t{df_train.shape}")
print(f"Dimension de df_test:\t{df_test.shape}")

Nombre d'exemples du label 10 pris pour apprendre: 98
Nombre d'exemples du label 3 pris pour apprendre: 97
Nombre d'exemples du label 17 pris pour apprendre: 92
Nombre d'exemples du label 4 pris pour apprendre: 93
Nombre d'exemples du label 12 pris pour apprendre: 96
Nombre d'exemples du label 19 pris pour apprendre: 60
Nombre d'exemples du label 11 pris pour apprendre: 96
Nombre d'exemples du label 13 pris pour apprendre: 96
Nombre d'exemples du label 0 pris pour apprendre: 78
Nombre d'exemples du label 8 pris pour apprendre: 97
Nombre d'exemples du label 7 pris pour apprendre: 94
Nombre d'exemples du label 5 pris pour apprendre: 98
Nombre d'exemples du label 1 pris pour apprendre: 95
Nombre d'exemples du label 14 pris pour apprendre: 96
Nombre d'exemples du label 16 pris pour apprendre: 89
Nombre d'exemples du label 6 pris pour apprendre: 96
Nombre d'exemples du label 9 pris pour apprendre: 96
Nombre d'exemples du label 18 pris pour apprendre: 76
Nombre d'exemples du label 2 pris pour apprendre: 95
Nombre d'exemples du label 15 pris pour apprendre: 98
Dimension de df_train:	(1836, 3)
Dimension de df_test:	(16630, 3)

# ======================================================
# Classification binaire avec Perceptron - Version 1
# ======================================================
# Cette version utilise une méthode de conversion directe des données
# via la fonction df2array (non détaillée ici)

# Sélection des deux classes à classifier
classe1 = 0
classe2 = 1

# Filtrage des données d'entraînement et de test
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en format binaire (-1/+1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Préparation des données d'entraînement et de test
X_train_bin = ut.df2array(df_binaire, index_mots)  # Conversion des features
y_train_bin = df_binaire['target_bin'].values      # Labels d'entraînement

X_test_bin = ut.df2array(df_test_bin, index_mots)  # Conversion des features
y_test_bin = df_test_bin['target_bin'].values      # Labels de test

# Initialisation du perceptron
perceptron = classif.ClassifierPerceptron(input_dimension=X_train_bin.shape[1], learning_rate=0.01)

# Listes pour stocker les performances
train_acc = []  # Précision sur le train set
test_acc = []   # Précision sur le test set

# Boucle d'entraînement
N = 100  # Nombre d'itérations

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    # Étape d'entraînement
    perceptron.train_step(X_train_bin, y_train_bin)
    
    # Prédictions et calcul de l'accuracy
    y_train_pred = np.array([perceptron.predict(x) for x in X_train_bin])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test_bin])
    
    # Enregistrement des performances
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())
    
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

# Visualisation des résultats
plt.plot(range(1,N+1),train_acc, label='Train')
plt.plot(range(1,N+1),test_acc, label='Test')  
plt.ylabel('Accuracy')
plt.xlabel("Etape")
plt.title("Évolution de l'accuracy pendant l'entraînement")
plt.legend()
plt.grid(True)
plt.show()

# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 1.2524452209472656 secondes

Accuracy finale (train): 0.9884393063583815
Accuracy finale (test) : 0.8220663265306123
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)]
Taux moyen de bonne classification : 0.9882
Écart-type : 0.0144

# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec Perceptron - Version 2
# ======================================================
# Cette version utilise explicitement un modèle Bag-of-Words (BoW)
# pour la vectorisation des textes

# Sélection des classes (identique à la version 1)
classe1 = 0
classe2 = 1

# Filtrage des données (identique à la version 1)
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels (identique à la version 1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Initialisation du perceptron
perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)

# Entraînement et évaluation
N = 100  # Nombre d'itérations
train_acc, test_acc = [], []  # Stockage des performances

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    # Étape d'entraînement
    perceptron.train_step(X_train, y_train_bin)
    
    # Prédictions
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    # Calcul et enregistrement des performances
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Performance du Perceptron avec BoW (mode binaire)")
plt.legend()
plt.grid(True)
plt.show()

# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.6399490833282471 secondes

Accuracy finale (train): 0.9884393063583815
Accuracy finale (test) : 0.8233418367346939
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)]
Taux moyen de bonne classification : 0.9882
Écart-type : 0.0144

# =================================================================
# Classification binaire avec Comptage de mots (Bag-of-Words count) avec Perceptron - Version 3
# =================================================================
# Cette version utilise la fréquence brute des mots comme caractéristiques

# Définition des classes à classifier
classe1 = 0
classe2 = 1

# Préparation des données - Filtrage des classes sélectionnées
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Transformation des labels en format binaire (-1 pour classe1, +1 pour classe2)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode comptage
# Le mode "count" enregistre le nombre d'occurrences de chaque mot
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Initialisation du perceptron avec le nombre de caractéristiques et taux d'apprentissage
perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)

# Boucle d'entraînement et évaluation
N = 100  # Nombre d'itérations
train_acc, test_acc = [], []  # Stockage des précisions

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    # Phase d'entraînement
    perceptron.train_step(X_train, y_train_bin)
    
    # Prédictions sur les ensembles d'entraînement et de test
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    # Calcul et enregistrement des précisions
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=count)")
plt.legend()
plt.grid(True)
plt.show()

print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.6322243213653564 secondes

Accuracy finale (train): 0.9884393063583815
Accuracy finale (test) : 0.8418367346938775
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(0.9705882352941176), np.float64(0.9705882352941176), np.float64(0.9705882352941176)]
Taux moyen de bonne classification : 0.9765
Écart-type : 0.0118

# =================================================================
# Classification binaire avec Fréquence relative (Bag-of-Words freq) avec Perceptron - Version 4
# =================================================================
# Cette version utilise la fréquence relative des mots comme caractéristiques

classe1 = 0
classe2 = 1

df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode fréquence
# Le mode "freq" utilise la fréquence relative (occurrences normalisées par document)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)

N = 100
train_acc, test_acc = [], []

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    perceptron.train_step(X_train, y_train_bin)
    
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=freq)")
plt.legend()
plt.grid(True)
plt.show()

print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.6305558681488037 secondes

Accuracy finale (train): 0.9884393063583815
Accuracy finale (test) : 0.8392857142857143
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7647
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8235
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7647058823529411), np.float64(0.7941176470588235), np.float64(0.8235294117647058)]
Taux moyen de bonne classification : 0.8176
Écart-type : 0.0343

# =================================================================
# Classification binaire avec TF-IDF avec Perceptron - Version 5
# =================================================================
# Cette version utilise le score TF-IDF comme caractéristiques

classe1 = 0
classe2 = 1

df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle TF-IDF
# TF-IDF pondère les mots par leur importance dans le document et le corpus
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)

N = 100
train_acc, test_acc = [], []

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    perceptron.train_step(X_train, y_train_bin)
    
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=tfidf)")
plt.legend()
plt.grid(True)
plt.show()

print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.6359288692474365 secondes

Accuracy finale (train): 0.9884393063583815
Accuracy finale (test) : 0.8367346938775511
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7647
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8235
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9118
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.7941176470588235), np.float64(0.7647058823529411), np.float64(0.8235294117647058), np.float64(0.9117647058823529)]
Taux moyen de bonne classification : 0.8353
Écart-type : 0.0546

# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec perceptron - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"   # "binary", "count", "freq", "tfidf"(fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptron
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words binary) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 1.2713229656219482 secondes
Accuracy entraînement : 0.9875
Accuracy test         : 0.4583

Itération 0: Accuracy = 0.4556
Itération 1: Accuracy = 0.4222
Itération 2: Accuracy = 0.4472
Itération 3: Accuracy = 0.4000
Itération 4: Accuracy = 0.4583
Taux moyen : 0.4367, Écart-type : 0.0223

# =================================================================
# Classification multi-classe avec (Bag-of-Words comptage) avec perceptron - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"   # "binary", "count", "freq", "tfidf"(fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptron
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words comptage) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 1.647778034210205 secondes
Accuracy entraînement : 0.9875
Accuracy test         : 0.4396

Itération 0: Accuracy = 0.4306
Itération 1: Accuracy = 0.4167
Itération 2: Accuracy = 0.4028
Itération 3: Accuracy = 0.4111
Itération 4: Accuracy = 0.4083
Taux moyen : 0.4139, Écart-type : 0.0095

# =================================================================
# Classification multi-classe avec (Bag-of-Words frequence) avec perceptron - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"   # "binary", "count", "freq", "tfidf"(fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptron
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words frequence) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 1.660815954208374 secondes
Accuracy entraînement : 0.9875
Accuracy test         : 0.4317

Itération 0: Accuracy = 0.4194
Itération 1: Accuracy = 0.3833
Itération 2: Accuracy = 0.3750
Itération 3: Accuracy = 0.4000
Itération 4: Accuracy = 0.4222
Taux moyen : 0.4000, Écart-type : 0.0188

# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec perceptron - Version 4
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptron
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words tf-idf) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 1.1476762294769287 secondes
Accuracy entraînement : 0.9875
Accuracy test         : 0.4479

Itération 0: Accuracy = 0.4333
Itération 1: Accuracy = 0.4056
Itération 2: Accuracy = 0.3750
Itération 3: Accuracy = 0.4222
Itération 4: Accuracy = 0.4000
Taux moyen : 0.4072, Écart-type : 0.0200

# ======================================================
# Classification binaire avec PerceptronBiais - Version 1
# ======================================================

# Sélection des deux classes à classifier
classe1 = 0
classe2 = 1

# Filtrage des données d'entraînement et de test
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en format binaire (-1/+1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Préparation des données d'entraînement et de test
X_train_bin = ut.df2array(df_binaire, index_mots)  # Conversion des features
y_train_bin = df_binaire['target_bin'].values      # Labels d'entraînement

X_test_bin = ut.df2array(df_test_bin, index_mots)  # Conversion des features
y_test_bin = df_test_bin['target_bin'].values      # Labels de test

# Initialisation du perceptron AVEC BIAIS
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train_bin.shape[1], learning_rate=0.01)

# Listes pour stocker les performances
train_acc = []  # Précision sur le train set
test_acc = []   # Précision sur le test set

# Boucle d'entraînement
N = 100  # Nombre d'itérations

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    # Étape d'entraînement
    perceptron.train_step(X_train_bin, y_train_bin)
    
    # Prédictions et calcul de l'accuracy
    y_train_pred = np.array([perceptron.predict(x) for x in X_train_bin])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test_bin])
    
    # Enregistrement des performances
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

# Visualisation des résultats
plt.plot(range(1, N+1), train_acc, label='Train')
plt.plot(range(1, N+1), test_acc, label='Test')  
plt.ylabel('Accuracy')
plt.xlabel("Étape")
plt.title("Évolution de l'accuracy pendant l'entraînement (avec biais)")
plt.legend()
plt.grid(True)
plt.show()

# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 1.2888462543487549 secondes

Accuracy finale (train): 0.9942196531791907
Accuracy finale (test) : 0.8647959183673469
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)]
Taux moyen de bonne classification : 0.9882
Écart-type : 0.0144

# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec PerceptronBiais - Version 2
# ======================================================
# Cette version utilise explicitement un modèle Bag-of-Words (BoW)
# pour la vectorisation des textes

# Sélection des classes (identique à la version 1)
classe1 = 0
classe2 = 1

# Filtrage des données (identique à la version 1)
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels (identique à la version 1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Initialisation du perceptron
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)

# Entraînement et évaluation
N = 100  # Nombre d'itérations
train_acc, test_acc = [], []  # Stockage des performances

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    # Étape d'entraînement
    perceptron.train_step(X_train, y_train_bin)
    
    # Prédictions
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    # Calcul et enregistrement des performances
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Performance du Perceptron avec BoW (mode binaire)")
plt.legend()
plt.grid(True)
plt.show()

# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.6842498779296875 secondes

Accuracy finale (train): 0.9942196531791907
Accuracy finale (test) : 0.8628826530612245
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)]
Taux moyen de bonne classification : 0.9882
Écart-type : 0.0144

# =================================================================
# Classification binaire avec Comptage de mots (Bag-of-Words count) avec PerceptronBiais - Version 3
# =================================================================
# Cette version utilise la fréquence brute des mots comme caractéristiques

# Définition des classes à classifier
classe1 = 0
classe2 = 1

# Préparation des données - Filtrage des classes sélectionnées
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Transformation des labels en format binaire (-1 pour classe1, +1 pour classe2)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode comptage
# Le mode "count" enregistre le nombre d'occurrences de chaque mot
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Initialisation du perceptron avec le nombre de caractéristiques et taux d'apprentissage
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)

# Boucle d'entraînement et évaluation
N = 100  # Nombre d'itérations
train_acc, test_acc = [], []  # Stockage des précisions

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    # Phase d'entraînement
    perceptron.train_step(X_train, y_train_bin)
    
    # Prédictions sur les ensembles d'entraînement et de test
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    # Calcul et enregistrement des précisions
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=count)")
plt.legend()
plt.grid(True)
plt.show()

print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.7144351005554199 secondes

Accuracy finale (train): 0.9942196531791907
Accuracy finale (test) : 0.8654336734693877
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)]
Taux moyen de bonne classification : 0.9882
Écart-type : 0.0144

# =================================================================
# Classification binaire avec Fréquence relative (Bag-of-Words freq) avec PerceptronBiais - Version 4
# =================================================================
# Cette version utilise la fréquence relative des mots comme caractéristiques

classe1 = 0
classe2 = 1
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode fréquence
# Le mode "freq" utilise la fréquence relative (occurrences normalisées par document)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)

N = 100
train_acc, test_acc = [], []

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    perceptron.train_step(X_train, y_train_bin)
    
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=freq)")
plt.legend()
plt.grid(True)
plt.show()

print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.7543280124664307 secondes

Accuracy finale (train): 0.884393063583815
Accuracy finale (test) : 0.7110969387755102
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.9705882352941176), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)]
Taux moyen de bonne classification : 0.9824
Écart-type : 0.0144

# =================================================================
# Classification binaire avec TF-IDF avec PerceptronBiais - Version 5
# =================================================================
# Cette version utilise le score TF-IDF comme caractéristiques

classe1 = 0
classe2 = 1
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle TF-IDF
# TF-IDF pondère les mots par leur importance dans le document et le corpus
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)

N = 100
train_acc, test_acc = [], []

# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
    perceptron.train_step(X_train, y_train_bin)
    
    y_train_pred = np.array([perceptron.predict(x) for x in X_train])
    y_test_pred = np.array([perceptron.predict(x) for x in X_test])
    
    train_acc.append((y_train_pred == y_train_bin).mean())
    test_acc.append((y_test_pred == y_test_bin).mean())

end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")

plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=tfidf)")
plt.legend()
plt.grid(True)
plt.show()

print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Temps total d'entraînement : 0.7282757759094238 secondes

Accuracy finale (train): 0.9942196531791907
Accuracy finale (test) : 0.9177295918367347
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 1.0000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)]
Taux moyen de bonne classification : 0.9882
Écart-type : 0.0144

# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec PerceptronBiais - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptronbiais
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words binary) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 14.851285934448242 secondes
Accuracy entraînement : 0.9891
Accuracy test         : 0.4260

Itération 0: Accuracy = 0.4639
Itération 1: Accuracy = 0.4028
Itération 2: Accuracy = 0.3833
Itération 3: Accuracy = 0.3889
Itération 4: Accuracy = 0.4278
Taux moyen : 0.4133, Écart-type : 0.0296

# =================================================================
# Classification multi-classe avec (Bag-of-Words comptage) avec PerceptronBiais - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptronbiais
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

# Passage en dense + normalisation log(1 + x)
X_train = np.log1p(X_train_sparse.toarray())
X_test = np.log1p(X_test_sparse.toarray())

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words comptage) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 15.709067106246948 secondes
Accuracy entraînement : 0.9891
Accuracy test         : 0.4524

Itération 0: Accuracy = 0.4528
Itération 1: Accuracy = 0.4333
Itération 2: Accuracy = 0.4028
Itération 3: Accuracy = 0.4111
Itération 4: Accuracy = 0.4278
Taux moyen : 0.4256, Écart-type : 0.0175

# =================================================================
# Classification multi-classe avec (Bag-of-Words frequence) avec PerceptronBiais - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptronbiais
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

# Passage en dense
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# L2-normalisation manuelle
def l2_normalize(X):
    norms = np.linalg.norm(X, axis=1, keepdims=True)
    norms[norms == 0] = 1
    return X / norms

X_train = l2_normalize(X_train)
X_test = l2_normalize(X_test)

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words frequence) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 22.410446166992188 secondes
Accuracy entraînement : 0.9815
Accuracy test         : 0.5198

Itération 0: Accuracy = 0.5167
Itération 1: Accuracy = 0.5139
Itération 2: Accuracy = 0.4944
Itération 3: Accuracy = 0.4861
Itération 4: Accuracy = 0.5111
Taux moyen : 0.5044, Écart-type : 0.0120

# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec PerceptronBiais - Version 4
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
learning_rate = 0.01
N = 100                         # Nombre d'itérations pour le perceptronbiais
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------

# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)

# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)

# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words tf-idf) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
    base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
    return classif.ClassifierMultiOAA(base)

perf = []
for i in range(nb_folds):
    Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
    clf = create_new_oaa()
    clf.train(Xapp, Yapp)
    Y_pred = np.array([clf.predict(x) for x in Xtest])
    acc = np.mean(Y_pred == Ytest)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) : 24.897457122802734 secondes
Accuracy entraînement : 0.9788
Accuracy test         : 0.5675

Itération 0: Accuracy = 0.5667
Itération 1: Accuracy = 0.5361
Itération 2: Accuracy = 0.5583
Itération 3: Accuracy = 0.5444
Itération 4: Accuracy = 0.5861
Taux moyen : 0.5583, Écart-type : 0.0175

# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance euclidienne (k = 3) - Version 1
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 2.79603 secondes
Accuracy (train) : 0.9133
Accuracy (test) : 0.5236
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6765
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6176
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5), np.float64(0.6764705882352942), np.float64(0.6176470588235294), np.float64(0.5), np.float64(0.5)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0744

# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance euclidienne (k = 3) - Version 2
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 2.79690 secondes
Accuracy (train) : 0.9306
Accuracy (test) : 0.6129
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6471
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7059
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.4706
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5), np.float64(0.6470588235294118), np.float64(0.7058823529411765), np.float64(0.5), np.float64(0.47058823529411764)]
Taux moyen de bonne classification : 0.5647
Écart-type : 0.0937

# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance euclidienne (k = 3) - Version 3
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 2.80271 secondes
Accuracy (train) : 0.9827
Accuracy (test) : 0.7577
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7353
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6176
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6765
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7059
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.7352941176470589), np.float64(0.6176470588235294), np.float64(0.6764705882352942), np.float64(0.7941176470588235), np.float64(0.7058823529411765)]
Taux moyen de bonne classification : 0.7059
Écart-type : 0.0588

# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance euclidienne (k = 3) - Version 4
# =================================================================

# Définition des deux classes binaires
classe1 = 0
classe2 = 1

# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 2.80374 secondes
Accuracy (train) : 0.9942
Accuracy (test) : 0.8361
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8235
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6471
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7353
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8235294117647058), np.float64(0.6470588235294118), np.float64(0.8823529411764706), np.float64(0.7352941176470589), np.float64(0.8529411764705882)]
Taux moyen de bonne classification : 0.7882
Écart-type : 0.0861

# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec KNN sklearn (k = 3) - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=3, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.007567167282104492 secondes
Accuracy entraînement : 0.3252
Accuracy test         : 0.0783

Itération 0: Accuracy = 0.0788
Itération 1: Accuracy = 0.0763
Itération 2: Accuracy = 0.0681
Itération 3: Accuracy = 0.0790
Itération 4: Accuracy = 0.0845
Taux moyen : 0.0773, Écart-type : 0.0053

# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec KNN sklearn (k = 3) - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=3, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.01612067222595215 secondes
Accuracy entraînement : 0.3883
Accuracy test         : 0.1278

Itération 0: Accuracy = 0.1005
Itération 1: Accuracy = 0.0981
Itération 2: Accuracy = 0.1199
Itération 3: Accuracy = 0.1281
Itération 4: Accuracy = 0.1444
Taux moyen : 0.1182, Écart-type : 0.0173

# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec KNN sklearn (k = 3) - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=3, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.01175999641418457 secondes
Accuracy entraînement : 0.3617
Accuracy test         : 0.1158

Itération 0: Accuracy = 0.1250
Itération 1: Accuracy = 0.0954
Itération 2: Accuracy = 0.1281
Itération 3: Accuracy = 0.1008
Itération 4: Accuracy = 0.0872
Taux moyen : 0.1073, Écart-type : 0.0163

# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec sklearn KNN (k = 3) - Version 4
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
k = 3
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=k, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe avec sklearn KNN) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3, TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe avec sklearn KNN) : 0.008476972579956055 secondes
Accuracy entraînement : 0.3203
Accuracy test         : 0.0981

Itération 0: Accuracy = 0.0815
Itération 1: Accuracy = 0.0763
Itération 2: Accuracy = 0.0845
Itération 3: Accuracy = 0.0926
Itération 4: Accuracy = 0.0845
Taux moyen : 0.0839, Écart-type : 0.0053

# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance euclidienne (k = 5) - Version 1
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 2.83509 secondes
Accuracy (train) : 0.7803
Accuracy (test) : 0.5485
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.4412
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6765
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5882
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6176
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.4411764705882353), np.float64(0.6764705882352942), np.float64(0.5882352941176471), np.float64(0.6176470588235294), np.float64(0.5)]
Taux moyen de bonne classification : 0.5647
Écart-type : 0.0840

# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance euclidienne (k = 5) - Version 2
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 2.96515 secondes
Accuracy (train) : 0.7919
Accuracy (test) : 0.5784
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6471
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6765
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6176
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5), np.float64(0.6470588235294118), np.float64(0.6764705882352942), np.float64(0.6176470588235294), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.6000
Écart-type : 0.0634

# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance euclidienne (k = 5) - Version 3
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 3.16788 secondes
Accuracy (train) : 0.8960
Accuracy (test) : 0.6849
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5294
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5294
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5294
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6765
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5294117647058824), np.float64(0.5294117647058824), np.float64(0.5294117647058824), np.float64(0.5588235294117647), np.float64(0.6764705882352942)]
Taux moyen de bonne classification : 0.5647
Écart-type : 0.0570

# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance euclidienne (k = 5) - Version 4
# =================================================================

# Définition des deux classes binaires
classe1 = 0
classe2 = 1

# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 3.26109 secondes
Accuracy (train) : 0.9653
Accuracy (test) : 0.6818
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5294
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5000
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.6765
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.4706
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7059
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5294117647058824), np.float64(0.5), np.float64(0.6764705882352942), np.float64(0.47058823529411764), np.float64(0.7058823529411765)]
Taux moyen de bonne classification : 0.5765
Écart-type : 0.0959

# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec KNN sklearn (k = 5) - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=5, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.008249759674072266 secondes
Accuracy entraînement : 0.2435
Accuracy test         : 0.0752

Itération 0: Accuracy = 0.0788
Itération 1: Accuracy = 0.0763
Itération 2: Accuracy = 0.0681
Itération 3: Accuracy = 0.0790
Itération 4: Accuracy = 0.0845
Taux moyen : 0.0773, Écart-type : 0.0053

# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec KNN sklearn (k = 5) - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=5, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.007130146026611328 secondes
Accuracy entraînement : 0.3110
Accuracy test         : 0.1286

Itération 0: Accuracy = 0.1005
Itération 1: Accuracy = 0.0981
Itération 2: Accuracy = 0.1199
Itération 3: Accuracy = 0.1281
Itération 4: Accuracy = 0.1444
Taux moyen : 0.1182, Écart-type : 0.0173

# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec KNN sklearn (k = 5) - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=5, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.010577917098999023 secondes
Accuracy entraînement : 0.2342
Accuracy test         : 0.0981

Itération 0: Accuracy = 0.1250
Itération 1: Accuracy = 0.0954
Itération 2: Accuracy = 0.1281
Itération 3: Accuracy = 0.1008
Itération 4: Accuracy = 0.0872
Taux moyen : 0.1073, Écart-type : 0.0163

# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec sklearn KNN (k = 5) - Version 4
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
k = 5
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=k, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe avec sklearn KNN) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3, TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe avec sklearn KNN) : 0.009913921356201172 secondes
Accuracy entraînement : 0.1699
Accuracy test         : 0.0780

Itération 0: Accuracy = 0.0707
Itération 1: Accuracy = 0.0708
Itération 2: Accuracy = 0.0708
Itération 3: Accuracy = 0.0981
Itération 4: Accuracy = 0.0736
Taux moyen : 0.0768, Écart-type : 0.0107

k = math.sqrt(len(newsgroups_df_neitoie))
k

135.88966112254457

# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance euclidienne (k = 135) - Version 1
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00003 secondes
Prédiction sur test effectuée en 3.18741 secondes
Accuracy (train) : 0.5491
Accuracy (test) : 0.5510
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance euclidienne (k = 135) - Version 2
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 3.16653 secondes
Accuracy (train) : 0.5491
Accuracy (test) : 0.5517
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance euclidienne (k = 135) - Version 3
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 3.08743 secondes
Accuracy (train) : 0.5491
Accuracy (test) : 0.5491
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance euclidienne (k = 135) - Version 4
# =================================================================

# Définition des deux classes binaires
classe1 = 0
classe2 = 1

# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 3.05594 secondes
Accuracy (train) : 0.5491
Accuracy (test) : 0.5491
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec KNN sklearn (k = 135) - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
k = 135
# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=135, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.01529693603515625 secondes
Accuracy entraînement : 0.0719
Accuracy test         : 0.0633

Itération 0: Accuracy = 0.0679
Itération 1: Accuracy = 0.0926
Itération 2: Accuracy = 0.0899
Itération 3: Accuracy = 0.0627
Itération 4: Accuracy = 0.0572
Taux moyen : 0.0741, Écart-type : 0.0145

# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec KNN sklearn (k = 135) - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
k = 135
# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=135, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.017328977584838867 secondes
Accuracy entraînement : 0.1198
Accuracy test         : 0.0977

Itération 0: Accuracy = 0.0707
Itération 1: Accuracy = 0.1035
Itération 2: Accuracy = 0.0981
Itération 3: Accuracy = 0.0817
Itération 4: Accuracy = 0.0845
Taux moyen : 0.0877, Écart-type : 0.0118

# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec KNN sklearn (k = 135) - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"   # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
k = 135
# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=135, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()

print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe) avec sklearn KNN : 0.013354063034057617 secondes
Accuracy entraînement : 0.0910
Accuracy test         : 0.0732

Itération 0: Accuracy = 0.0625
Itération 1: Accuracy = 0.0572
Itération 2: Accuracy = 0.0708
Itération 3: Accuracy = 0.0599
Itération 4: Accuracy = 0.0599
Taux moyen : 0.0621, Écart-type : 0.0047

# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec sklearn KNN (k = 135) - Version 4
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
k = 135
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------

knn_classifier = KNeighborsClassifier(n_neighbors=k, metric='euclidean')

start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe avec sklearn KNN) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3, TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sur train)
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
    
    clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    clf.fit(Xapp, Yapp)
    Y_pred = clf.predict(Xval)
    
    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (multi-classe avec sklearn KNN) : 0.017281770706176758 secondes
Accuracy entraînement : 0.1155
Accuracy test         : 0.0873

Itération 0: Accuracy = 0.0543
Itération 1: Accuracy = 0.0572
Itération 2: Accuracy = 0.0845
Itération 3: Accuracy = 0.0654
Itération 4: Accuracy = 0.0572
Taux moyen : 0.0637, Écart-type : 0.0110

# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance cosinus (k = 3) - Version 1
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.33372 secondes
Accuracy (train) : 0.9191
Accuracy (test) : 0.8323
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9412
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.9411764705882353), np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7941176470588235)]
Taux moyen de bonne classification : 0.8647
Écart-type : 0.0478

# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance cosinus (k = 3) - Version 2
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.31408 secondes
Accuracy (train) : 0.9133
Accuracy (test) : 0.8629
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.8823529411764706), np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7941176470588235)]
Taux moyen de bonne classification : 0.8529
Écart-type : 0.0322

# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance cosinus (k = 3) - Version 3
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.28902 secondes
Accuracy (train) : 0.9133
Accuracy (test) : 0.8622
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.8823529411764706), np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7941176470588235)]
Taux moyen de bonne classification : 0.8529
Écart-type : 0.0322

# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance cosinus (k = 3) - Version 4
# =================================================================

# Définition des deux classes binaires
classe1 = 0
classe2 = 1

# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.44204 secondes
Accuracy (train) : 0.9480
Accuracy (test) : 0.8807
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9412
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9412
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.9411764705882353), np.float64(0.9411764705882353), np.float64(0.8529411764705882), np.float64(0.8823529411764706), np.float64(0.8529411764705882)]
Taux moyen de bonne classification : 0.8941
Écart-type : 0.0399

# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec sklearn KNN (cosine distance, k=3) - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"
k = 3
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.003222942352294922 secondes
Accuracy entraînement : 0.5501
Accuracy test         : 0.2569

Itération 0: Accuracy = 0.2609
Itération 1: Accuracy = 0.2316
Itération 2: Accuracy = 0.2316
Itération 3: Accuracy = 0.3025
Itération 4: Accuracy = 0.2289
Taux moyen : 0.2511, Écart-type : 0.0282

# =================================================================
# Classification multi-classe avec (Bag-of-Words comptage) avec sklearn KNN (cosine distance, k=3) - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"
k = 3
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.002089977264404297 secondes
Accuracy entraînement : 0.5561
Accuracy test         : 0.3004

Itération 0: Accuracy = 0.2799
Itération 1: Accuracy = 0.2725
Itération 2: Accuracy = 0.2807
Itération 3: Accuracy = 0.2616
Itération 4: Accuracy = 0.2861
Taux moyen : 0.2761, Écart-type : 0.0085

# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec sklearn KNN (cosine distance, k=3) - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"
k = 3
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.0019378662109375 secondes
Accuracy entraînement : 0.5561
Accuracy test         : 0.3004

Itération 0: Accuracy = 0.2799
Itération 1: Accuracy = 0.2725
Itération 2: Accuracy = 0.2807
Itération 3: Accuracy = 0.2616
Itération 4: Accuracy = 0.2861
Taux moyen : 0.2761, Écart-type : 0.0085

# =================================================================
# Classification multi-classe avec (Bag-of-Words TF-IDF) avec sklearn KNN (cosine distance, k=3) - Version 4
# =================================================================

# ---------------------------
# Paramètres
# ---------------------------
k = 3
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# TF-IDF vectorisation (manuelle)
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement sklearn KNN avec distance cosinus
# ---------------------------
D_train = cosine_distances(X_train)           
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (sklearn + cosine distance) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------
D_test = cosine_distances(X_test, X_train)        # distance test vs train

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (Stratifiée)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (sklearn + cosine distance) : 0.0018210411071777344 secondes
Accuracy entraînement : 0.6389
Accuracy test         : 0.3996

Itération 0: Accuracy = 0.3668
Itération 1: Accuracy = 0.3324
Itération 2: Accuracy = 0.3924
Itération 3: Accuracy = 0.3842
Itération 4: Accuracy = 0.3924
Taux moyen : 0.3736, Écart-type : 0.0226

# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance cosinus (k = 5) - Version 1
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.32580 secondes
Accuracy (train) : 0.9133
Accuracy (test) : 0.8469
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.8529411764705882), np.float64(0.7941176470588235), np.float64(0.8823529411764706), np.float64(0.7941176470588235)]
Taux moyen de bonne classification : 0.8412
Écart-type : 0.0399

# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance cosinus (k = 5) - Version 2
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.31347 secondes
Accuracy (train) : 0.9191
Accuracy (test) : 0.8661
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9118
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.9117647058823529), np.float64(0.8529411764705882), np.float64(0.7941176470588235), np.float64(0.8823529411764706), np.float64(0.8529411764705882)]
Taux moyen de bonne classification : 0.8588
Écart-type : 0.0390

# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance cosinus (k = 5) - Version 3
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00004 secondes
Prédiction sur test effectuée en 1.29489 secondes
Accuracy (train) : 0.9191
Accuracy (test) : 0.8654
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9118
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.7941
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.9117647058823529), np.float64(0.8529411764705882), np.float64(0.7941176470588235), np.float64(0.8823529411764706), np.float64(0.8529411764705882)]
Taux moyen de bonne classification : 0.8588
Écart-type : 0.0390

# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance cosinus (k = 5) - Version 4
# =================================================================

# Définition des deux classes binaires
classe1 = 0
classe2 = 1

# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.30947 secondes
Accuracy (train) : 0.9480
Accuracy (test) : 0.8884
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9706
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8824
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.9412
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.8529
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.9705882352941176), np.float64(0.8823529411764706), np.float64(0.9411764705882353), np.float64(0.8529411764705882)]
Taux moyen de bonne classification : 0.9059
Écart-type : 0.0432

# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec sklearn KNN (cosine distance, k=5) - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"
k = 5
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.0022890567779541016 secondes
Accuracy entraînement : 0.5349
Accuracy test         : 0.2896

Itération 0: Accuracy = 0.2989
Itération 1: Accuracy = 0.2589
Itération 2: Accuracy = 0.2807
Itération 3: Accuracy = 0.3079
Itération 4: Accuracy = 0.2807
Taux moyen : 0.2854, Écart-type : 0.0170

# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec sklearn KNN (cosine distance, k=5) - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"
k = 5
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.00215911865234375 secondes
Accuracy entraînement : 0.5664
Accuracy test         : 0.3333

Itération 0: Accuracy = 0.3043
Itération 1: Accuracy = 0.3106
Itération 2: Accuracy = 0.3161
Itération 3: Accuracy = 0.3243
Itération 4: Accuracy = 0.3161
Taux moyen : 0.3143, Écart-type : 0.0066

# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec sklearn KNN (cosine distance, k=5) - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"
k = 5
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.00177001953125 secondes
Accuracy entraînement : 0.5670
Accuracy test         : 0.3332

Itération 0: Accuracy = 0.3043
Itération 1: Accuracy = 0.3106
Itération 2: Accuracy = 0.3161
Itération 3: Accuracy = 0.3270
Itération 4: Accuracy = 0.3161
Taux moyen : 0.3148, Écart-type : 0.0075

# =================================================================
# Classification multi-classe avec (Bag-of-Words TF-IDF) avec sklearn KNN (cosine distance, k=5) - Version 4
# =================================================================

# ---------------------------
# Paramètres
# ---------------------------
k = 5
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# TF-IDF vectorisation (manuelle)
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement sklearn KNN avec distance cosinus
# ---------------------------
D_train = cosine_distances(X_train)       
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (sklearn + cosine distance) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------
D_test = cosine_distances(X_test, X_train)        # distance test vs train

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (Stratifiée)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (sklearn + cosine distance) : 0.0019829273223876953 secondes
Accuracy entraînement : 0.6275
Accuracy test         : 0.4408

Itération 0: Accuracy = 0.4484
Itération 1: Accuracy = 0.4060
Itération 2: Accuracy = 0.4223
Itération 3: Accuracy = 0.4251
Itération 4: Accuracy = 0.4114
Taux moyen : 0.4226, Écart-type : 0.0146

# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance cosinus (k = 135) - Version 1
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.39356 secondes
Accuracy (train) : 0.5954
Accuracy (test) : 0.5778
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance cosinus (k = 135) - Version 2
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.27433 secondes
Accuracy (train) : 0.5954
Accuracy (test) : 0.5759
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance cosinus (k = 135) - Version 3
# =================================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.28890 secondes
Accuracy (train) : 0.5954
Accuracy (test) : 0.5765
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance cosinus (k = 135) - Version 4
# =================================================================

# Définition des deux classes binaires
classe1 = 0
classe2 = 1

# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)

# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()

# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)

# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")

# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")

# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")

# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()

Apprentissage effectué en 0.00002 secondes
Prédiction sur test effectuée en 1.37608 secondes
Accuracy (train) : 0.6012
Accuracy (test) : 0.5848
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5588
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)]
Taux moyen de bonne classification : 0.5588
Écart-type : 0.0000

# =================================================================
# Classification multi-classe avec (Bag-of-Words Binaire) avec sklearn KNN (cosine distance, k=135) - Version 1
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"
k = 135
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.0017940998077392578 secondes
Accuracy entraînement : 0.4172
Accuracy test         : 0.3843

Itération 0: Accuracy = 0.3533
Itération 1: Accuracy = 0.3651
Itération 2: Accuracy = 0.3569
Itération 3: Accuracy = 0.3406
Itération 4: Accuracy = 0.3787
Taux moyen : 0.3589, Écart-type : 0.0127

# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec sklearn KNN (cosine distance, k=135) - Version 2
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"
k = 135
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.0018076896667480469 secondes
Accuracy entraînement : 0.4336
Accuracy test         : 0.4026

Itération 0: Accuracy = 0.3967
Itération 1: Accuracy = 0.3760
Itération 2: Accuracy = 0.3842
Itération 3: Accuracy = 0.3978
Itération 4: Accuracy = 0.3760
Taux moyen : 0.3862, Écart-type : 0.0096

# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec sklearn KNN (cosine distance, k=135) - Version 3
# =================================================================

# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"
k = 135
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)

knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")

D_test = cosine_distances(X_test, X_train)

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée
# ---------------------------

skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (avec sklearn + cosine distance) : 0.001825094223022461 secondes
Accuracy entraînement : 0.4341
Accuracy test         : 0.4025

Itération 0: Accuracy = 0.3967
Itération 1: Accuracy = 0.3760
Itération 2: Accuracy = 0.3842
Itération 3: Accuracy = 0.3978
Itération 4: Accuracy = 0.3760
Taux moyen : 0.3862, Écart-type : 0.0096

# =================================================================
# Classification multi-classe avec (Bag-of-Words TF-IDF) avec sklearn KNN (cosine distance, k=135) - Version 4
# =================================================================

# ---------------------------
# Paramètres
# ---------------------------
k = 135
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# TF-IDF vectorisation (manuelle)
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement sklearn KNN avec distance cosinus
# ---------------------------
D_train = cosine_distances(X_train)              
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')

start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (sklearn + cosine distance) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------
D_test = cosine_distances(X_test, X_train)        # distance test vs train

y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)

# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (Stratifiée)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []

for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
    Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
    Xval, Yval = X_train[test_idx], y_train_multi[test_idx]

    Dapp = cosine_distances(Xapp)
    Dval = cosine_distances(Xval, Xapp)

    clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
    clf.fit(Dapp, Yapp)
    Y_pred = clf.predict(Dval)

    acc = np.mean(Y_pred == Yval)
    print(f"Itération {i}: Accuracy = {acc:.4f}")
    perf.append(acc)

moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")

Temps d'entraînement (sklearn + cosine distance) : 0.0019979476928710938 secondes
Accuracy entraînement : 0.5310
Accuracy test         : 0.4924

Itération 0: Accuracy = 0.4864
Itération 1: Accuracy = 0.4387
Itération 2: Accuracy = 0.5068
Itération 3: Accuracy = 0.4605
Itération 4: Accuracy = 0.4877
Taux moyen : 0.4760, Écart-type : 0.0238

# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec Naive Bayes - Version 1
# ======================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en 0 et 1 (plus simple pour Naive Bayes)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec Bag-of-Words mode binaire (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)

start = time.time()
nb_classifier.train(X_train_sparse, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier.predict(X_train_sparse)
y_test_pred = nb_classifier.predict(X_test_sparse)

# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_sparse, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes binaire")
plt.show()

Temps d'entraînement: 0.0023260116577148438 secondes
Accuracy finale (train): 0.9826589595375722
Accuracy finale (test): 0.920280612244898
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.4965
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5104
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.4965
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5104
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5035
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.49653979238754326), np.float64(0.5103806228373703), np.float64(0.49653979238754326), np.float64(0.5103806228373703), np.float64(0.5034602076124568)]
Taux moyen de bonne classification : 0.5035
Écart-type : 0.0062

# ======================================================
# Classification binaire avec Bag-of-Words (Count) avec Naive Bayes - Version 2
# ======================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en 0 et 1 (plus simple pour Naive Bayes)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec Bag-of-Words mode count (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)

start = time.time()
nb_classifier.train(X_train_sparse, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier.predict(X_train_sparse)
y_test_pred = nb_classifier.predict(X_test_sparse)

# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_sparse, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes avec BoW (count)")
plt.show()

Temps d'entraînement: 0.0003299713134765625 secondes
Accuracy finale (train): 0.9826589595375722
Accuracy finale (test): 0.9196428571428571
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5035
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5069
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5069
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5104
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5069
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5034602076124568), np.float64(0.5069204152249135), np.float64(0.5069204152249135), np.float64(0.5103806228373703), np.float64(0.5069204152249135)]
Taux moyen de bonne classification : 0.5069
Écart-type : 0.0022

# ======================================================
# Classification binaire avec Bag-of-Words (Frequence) avec Naive Bayes - Version 3
# ======================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en 0 et 1 (plus simple pour Naive Bayes)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation avec Bag-of-Words mode freq (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)

start = time.time()
nb_classifier.train(X_train_sparse, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier.predict(X_train_sparse)
y_test_pred = nb_classifier.predict(X_test_sparse)

# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_sparse, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes avec BoW (freq)")
plt.show()

Temps d'entraînement: 0.00034308433532714844 secondes
Accuracy finale (train): 0.9884393063583815
Accuracy finale (test): 0.8131377551020408
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5242
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5242
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5346
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5311
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5242
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5242214532871973), np.float64(0.5242214532871973), np.float64(0.5346020761245674), np.float64(0.5311418685121108), np.float64(0.5242214532871973)]
Taux moyen de bonne classification : 0.5277
Écart-type : 0.0044

# ======================================================
# Classification binaire avec TF-IDF avec Naive Bayes - Version 4
# ======================================================

# Sélection des classes
classe1 = 0
classe2 = 1

# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Conversion des labels en 0 et 1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values

# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation TF-IDF manuelle (avec la fonction fournie)
X_train_tfidf, vocab_index = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_tfidf, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)

start = time.time()
nb_classifier.train(X_train_tfidf, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier.predict(X_train_tfidf)
y_test_pred = nb_classifier.predict(X_test_tfidf)

# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_tfidf, y_train_bin), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes avec TF-IDF manuel")
plt.show()

Temps d'entraînement: 0.00033593177795410156 secondes
Accuracy finale (train): 0.9884393063583815
Accuracy finale (test): 0.8679846938775511
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5104
Itération 1: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5208
Itération 2: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5311
Itération 3: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5138
Itération 4: taille base app.= 139	taille base test=34	Taux de bonne classif: 0.5208
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.5103806228373703), np.float64(0.5207612456747405), np.float64(0.5311418685121108), np.float64(0.513840830449827), np.float64(0.5207612456747405)]
Taux moyen de bonne classification : 0.5194
Écart-type : 0.0071

# ======================================================
# Classification multiclasse avec Binary avec Naive Bayes - Version 1
# ======================================================

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()

y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values

# Vectorisation avec Bag-of-Words mode binary (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)

# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_sparse, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_sparse)
y_test_pred = nb_classifier_multi.predict(X_test_sparse)

# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_sparse, y_train_multi), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec binary")
plt.show()

Temps d'entraînement: 0.007356166839599609 secondes
Accuracy finale (train): 0.8867102396514162
Accuracy finale (test): 0.4631990378833434
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0515
Itération 1: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0520
Itération 2: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0511
Itération 3: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0516
Itération 4: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0516
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.05145061728395062), np.float64(0.05201388888888889), np.float64(0.05114969135802469), np.float64(0.051604938271604936), np.float64(0.051604938271604936)]
Taux moyen de bonne classification : 0.0516
Écart-type : 0.0003

# ======================================================
# Classification multiclasse avec Comptage avec Naive Bayes - Version 2
# ======================================================

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()

y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values

# Vectorisation avec Bag-of-Words mode count (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)

# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_sparse, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_sparse)
y_test_pred = nb_classifier_multi.predict(X_test_sparse)

# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_sparse, y_train_multi), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec count")
plt.show()

Temps d'entraînement: 0.0053441524505615234 secondes
Accuracy finale (train): 0.829520697167756
Accuracy finale (test): 0.4488274203247144
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0504
Itération 1: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0517
Itération 2: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0502
Itération 3: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0507
Itération 4: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0507
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.05043981481481481), np.float64(0.0517283950617284), np.float64(0.05015432098765432), np.float64(0.05065586419753086), np.float64(0.050709876543209874)]
Taux moyen de bonne classification : 0.0507
Écart-type : 0.0005

# ======================================================
# Classification multiclasse avec Frequence avec Naive Bayes - Version 3
# ======================================================

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()

y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values

# Vectorisation avec Bag-of-Words mode count (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)

# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_sparse, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_sparse)
y_test_pred = nb_classifier_multi.predict(X_test_sparse)

# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_sparse, y_train_multi), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec count")
plt.show()

Temps d'entraînement: 0.008103132247924805 secondes
Accuracy finale (train): 0.789760348583878
Accuracy finale (test): 0.4141912206855081
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0522
Itération 1: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0522
Itération 2: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0520
Itération 3: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0522
Itération 4: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0522
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.052237654320987655), np.float64(0.052222222222222225), np.float64(0.05201388888888889), np.float64(0.052160493827160495), np.float64(0.05219907407407407)]
Taux moyen de bonne classification : 0.0522
Écart-type : 0.0001

# ======================================================
# Classification multiclasse avec TF-IDF avec Naive Bayes - Version 4
# ======================================================

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()

y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values

# Vectorisation TF-IDF manuelle (avec la fonction fournie)
X_train_tfidf, vocab_index = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_tfidf, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)

# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_tfidf, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")

# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_tfidf)
y_test_pred = nb_classifier_multi.predict(X_test_tfidf)

# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)

# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_tfidf, y_train_multi), nb_folds)

print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")

# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec TF-IDF")
plt.show()

Temps d'entraînement: 0.005766153335571289 secondes
Accuracy finale (train): 0.9183006535947712
Accuracy finale (test): 0.49284425736620563
------ affichage validation croisée (optionnel)
Itération 0: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0520
Itération 1: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0520
Itération 2: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0518
Itération 3: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0518
Itération 4: taille base app.= 1476	taille base test=360	Taux de bonne classif: 0.0519
------ fin affichage validation croisée
Taux de bonne classification par fold : [np.float64(0.052021604938271605), np.float64(0.051959876543209875), np.float64(0.05184413580246913), np.float64(0.05183641975308642), np.float64(0.05189814814814815)]
Taux moyen de bonne classification : 0.0519
Écart-type : 0.0001

# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec Arbre de decision - Version 1
# ======================================================

# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1

# Réduction de la taille pour accélérer les tests
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Préparation des données
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Utilisation de Scikit-learn pour l'arbre de décision
# ---------------------------
arbre_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=3000, random_state=0)

# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - sklearn) :", end - start, "secondes")

# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)

# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag of words binary)")
plt.grid(False)
plt.tight_layout()
plt.show()

Temps d'entraînement (Arbre de Décision - sklearn) : 0.016485214233398438 secondes
Accuracy entraînement : 0.9942
Accuracy test         : 0.7838
Taux de bonne classification par fold : [0.68571429 0.85714286 0.68571429 0.76470588 0.67647059]
Taux moyen de bonne classification : 0.7339
Écart-type : 0.0694

# ======================================================
# Classification binaire avec Bag-of-Words (Comptage) avec Arbre de decision - Version 2
# ======================================================

# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1

# Réduction de la taille pour accélérer les tests
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Préparation des données
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Utilisation de Scikit-learn pour l'arbre de décision
# ---------------------------
arbre_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=3000, random_state=0)

# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - sklearn) :", end - start, "secondes")

# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)

# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag of words comptage)")
plt.grid(False)
plt.tight_layout()
plt.show()

Temps d'entraînement (Arbre de Décision - sklearn) : 0.013701915740966797 secondes
Accuracy entraînement : 0.9942
Accuracy test         : 0.7838
Taux de bonne classification par fold : [0.68571429 0.85714286 0.71428571 0.76470588 0.67647059]
Taux moyen de bonne classification : 0.7397
Écart-type : 0.0663

# ======================================================
# Classification binaire avec Bag-of-Words (Frequence) avec Arbre de decision - Version 3
# ======================================================

# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1

# Réduction de la taille pour accélérer les tests
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Préparation des données
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Utilisation de Scikit-learn pour l'arbre de décision
# ---------------------------
arbre_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=3000, random_state=0)

# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - sklearn) :", end - start, "secondes")

# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)

# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag of words comptage)")
plt.grid(False)
plt.tight_layout()
plt.show()

Temps d'entraînement (Arbre de Décision - sklearn) : 0.014307022094726562 secondes
Accuracy entraînement : 0.9942
Accuracy test         : 0.7640
Taux de bonne classification par fold : [0.77142857 0.74285714 0.65714286 0.70588235 0.64705882]
Taux moyen de bonne classification : 0.7049
Écart-type : 0.0479

# ======================================================
# Classification binaire avec Bag-of-Words (tf-idf) avec Arbre de decision - Version 4
# ======================================================

# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1

# Réduction de la taille pour accélérer les tests (optionnel)
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()

# Labels
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']

y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()

# ---------------------------
# TF-IDF Vectorisation (manuelle)
# ---------------------------
X_train_sparse, vocab_index = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Arbre de Décision (scikit-learn)
# ---------------------------
arbre_classifier = DecisionTreeClassifier(
    criterion="entropy", 
    max_depth=3000,
    class_weight="balanced",
    random_state=0
)

# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - TF-IDF) :", end - start, "secondes")

# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)

# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()

Temps d'entraînement (Arbre de Décision - TF-IDF) : 0.016049861907958984 secondes
Accuracy entraînement : 0.9942
Accuracy test         : 0.7615
Taux de bonne classification par fold : [0.77142857 0.74285714 0.57142857 0.73529412 0.61764706]
Taux moyen de bonne classification : 0.6877
Écart-type : 0.0784

# ==========================================================
# Classification multi-classe avec Arbre de Décision (Bag-of-Words binary) - Version 1
# ==========================================================

# ---------------------------
# Paramètres
# ---------------------------
mode_vectorisation = "binary"  # "binary", "count", "freq", "tfidf"
max_depth = 3000                 # profondeur maximale de l’arbre
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle
# ---------------------------

# Initialisation du classifieur sklearn
tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)

# Chronométrage
start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag-of-words binary)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sklearn)
# ---------------------------

cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

Temps d'entraînement (multi-classe - arbre de décision) : 1.058288335800171 secondes
Accuracy entraînement : 0.9891
Accuracy test         : 0.2162

Taux de bonne classification par fold : [0.20652174 0.1852861  0.21253406 0.20435967 0.20980926]
Taux moyen de bonne classification : 0.2037
Écart-type : 0.0096

# ==========================================================
# Classification multi-classe avec Arbre de Décision (Bag-of-Words comptage) - Version 2
# ==========================================================

# ---------------------------
# Paramètres
# ---------------------------
mode_vectorisation = "count"  # "binary", "count", "freq", "tfidf"
max_depth = 3000                 # profondeur maximale de l’arbre
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle
# ---------------------------

# Initialisation du classifieur sklearn
tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)

# Chronométrage
start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag-of-words count)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sklearn)
# ---------------------------

cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

Temps d'entraînement (multi-classe - arbre de décision) : 1.03580904006958 secondes
Accuracy entraînement : 0.9891
Accuracy test         : 0.2191

Taux de bonne classification par fold : [0.20380435 0.1880109  0.22343324 0.22615804 0.23705722]
Taux moyen de bonne classification : 0.2157
Écart-type : 0.0175

# ==========================================================
# Classification multi-classe avec Arbre de Décision (Bag-of-Words frequence) - Version 3
# ==========================================================

# ---------------------------
# Paramètres
# ---------------------------
mode_vectorisation = "freq"  # "binary", "count", "freq", "tfidf"
max_depth = 3000                 # profondeur maximale de l’arbre
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle
# ---------------------------

# Initialisation du classifieur sklearn
tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)

# Chronométrage
start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag-of-words count)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sklearn)
# ---------------------------

cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

Temps d'entraînement (multi-classe - arbre de décision) : 1.2291460037231445 secondes
Accuracy entraînement : 0.9891
Accuracy test         : 0.2162

Taux de bonne classification par fold : [0.20652174 0.19618529 0.19618529 0.22070845 0.22615804]
Taux moyen de bonne classification : 0.2092
Écart-type : 0.0124

# ==========================================================
# Classification multi-classe avec Arbre de Décision (TF-IDF avec bag_of_words_tfidf_manual) - Version 4
# ==========================================================

# ---------------------------
# Paramètres
# ---------------------------
max_depth = 3000
nb_folds = 5

# ---------------------------
# Préparation des données
# ---------------------------

# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values

# Vectorisation avec ta fonction TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)

X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()

# ---------------------------
# Entraînement du modèle
# ---------------------------

tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)

start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")

# ---------------------------
# Prédictions
# ---------------------------

y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)

# ---------------------------
# Évaluation des performances
# ---------------------------

acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)

print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test         : {acc_test:.4f}")

cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (TF-IDF manuel)")
plt.grid(False)
plt.tight_layout()
plt.show()

# ---------------------------
# Validation croisée (sklearn)
# ---------------------------

cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')

print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")

Temps d'entraînement (multi-classe - arbre de décision) : 1.1658222675323486 secondes
Accuracy entraînement : 0.9891
Accuracy test         : 0.2163

Taux de bonne classification par fold : [0.20652174 0.19618529 0.19618529 0.22070845 0.22615804]
Taux moyen de bonne classification : 0.2092
Écart-type : 0.0124

# Sélectionner les N premiers échantillons (par exemple 150)
N = 150
texts = newsgroups_df_neitoie['messages'][:N]  # Prendre les 150 premiers messages

# Représentation par sac de mots (binary=True indique la présence/absence des mots)
vectorizer = CountVectorizer(binary=True)
X_small = vectorizer.fit_transform(texts).toarray()  # Générer une matrice binaire de fréquence des mots

X_small_df = pd.DataFrame(X_small)  # Convertir au format DataFrame

# Appel de l'algorithme de clustering hiérarchique CHA (avec différentes méthodes de liaison)
clust.CHA(X_small_df, linkage='centroid', verbose=False, dendrogramme=True)  # Liaison par centroïde
clust.CHA(X_small_df, linkage='complete', verbose=False, dendrogramme=True)  # Liaison complète
clust.CHA(X_small_df, linkage='average', verbose=False, dendrogramme=True)  # Liaison moyenne
clust.CHA(X_small_df, linkage='simple', verbose=False, dendrogramme=True)  # Liaison simple

[[53, 98, np.float64(3.4641016151377544), 2],
 [99, 150, np.float64(3.4641016151377544), 3],
 [11, 151, np.float64(3.605551275463989), 4],
 [80, 152, np.float64(3.7416573867739413), 5],
 [124, 153, np.float64(3.7416573867739413), 6],
 [14, 154, np.float64(3.872983346207417), 7],
 [144, 155, np.float64(3.872983346207417), 8],
 [146, 156, np.float64(3.872983346207417), 9],
 [73, 157, np.float64(4.0), 10],
 [88, 158, np.float64(4.123105625617661), 11],
 [133, 159, np.float64(4.242640687119285), 12],
 [117, 160, np.float64(4.358898943540674), 13],
 [47, 161, np.float64(4.47213595499958), 14],
 [43, 162, np.float64(4.69041575982343), 15],
 [68, 163, np.float64(4.898979485566356), 16],
 [127, 164, np.float64(5.0), 17],
 [71, 165, np.float64(5.0990195135927845), 18],
 [37, 166, np.float64(5.196152422706632), 19],
 [52, 167, np.float64(5.196152422706632), 20],
 [90, 168, np.float64(5.196152422706632), 21],
 [27, 169, np.float64(5.385164807134504), 22],
 [34, 170, np.float64(5.385164807134504), 23],
 [49, 171, np.float64(5.385164807134504), 24],
 [6, 172, np.float64(5.477225575051661), 25],
 [103, 173, np.float64(5.477225575051661), 26],
 [102, 174, np.float64(5.5677643628300215), 27],
 [31, 175, np.float64(5.656854249492381), 28],
 [69, 176, np.float64(5.656854249492381), 29],
 [32, 177, np.float64(5.744562646538029), 30],
 [84, 178, np.float64(5.744562646538029), 31],
 [147, 179, np.float64(5.830951894845301), 32],
 [10, 180, np.float64(5.916079783099616), 33],
 [25, 181, np.float64(6.0), 34],
 [33, 182, np.float64(6.0), 35],
 [135, 183, np.float64(6.0), 36],
 [106, 184, np.float64(6.082762530298219), 37],
 [100, 185, np.float64(6.244997998398398), 38],
 [104, 186, np.float64(6.244997998398398), 39],
 [129, 187, np.float64(6.244997998398398), 40],
 [140, 188, np.float64(6.244997998398398), 41],
 [35, 189, np.float64(6.324555320336759), 42],
 [66, 190, np.float64(6.324555320336759), 43],
 [76, 191, np.float64(6.4031242374328485), 44],
 [115, 192, np.float64(6.48074069840786), 45],
 [13, 193, np.float64(6.557438524302), 46],
 [41, 194, np.float64(6.6332495807108), 47],
 [83, 195, np.float64(6.6332495807108), 48],
 [62, 196, np.float64(6.708203932499369), 49],
 [65, 197, np.float64(6.708203932499369), 50],
 [1, 198, np.float64(6.782329983125268), 51],
 [36, 199, np.float64(6.782329983125268), 52],
 [58, 200, np.float64(6.782329983125268), 53],
 [143, 201, np.float64(6.855654600401044), 54],
 [9, 202, np.float64(6.928203230275509), 55],
 [21, 203, np.float64(6.928203230275509), 56],
 [8, 204, np.float64(7.0), 57],
 [107, 205, np.float64(7.0), 58],
 [142, 206, np.float64(7.0), 59],
 [97, 207, np.float64(7.0710678118654755), 60],
 [108, 208, np.float64(7.0710678118654755), 61],
 [123, 209, np.float64(7.211102550927978), 62],
 [81, 210, np.float64(7.280109889280518), 63],
 [50, 211, np.float64(7.3484692283495345), 64],
 [55, 212, np.float64(7.3484692283495345), 65],
 [5, 213, np.float64(7.483314773547883), 66],
 [67, 214, np.float64(7.483314773547883), 67],
 [116, 215, np.float64(7.54983443527075), 68],
 [111, 216, np.float64(7.615773105863909), 69],
 [145, 217, np.float64(7.681145747868608), 70],
 [77, 218, np.float64(7.745966692414834), 71],
 [92, 219, np.float64(7.745966692414834), 72],
 [17, 220, np.float64(7.810249675906654), 73],
 [149, 221, np.float64(7.810249675906654), 74],
 [85, 222, np.float64(7.937253933193772), 75],
 [114, 223, np.float64(8.0), 76],
 [148, 224, np.float64(8.0), 77],
 [122, 225, np.float64(8.06225774829855), 78],
 [125, 226, np.float64(8.12403840463596), 79],
 [138, 227, np.float64(8.12403840463596), 80],
 [39, 228, np.float64(8.306623862918075), 81],
 [4, 229, np.float64(8.366600265340756), 82],
 [51, 230, np.float64(8.426149773176359), 83],
 [78, 231, np.float64(8.426149773176359), 84],
 [82, 232, np.float64(8.54400374531753), 85],
 [3, 233, np.float64(8.660254037844387), 86],
 [23, 234, np.float64(8.660254037844387), 87],
 [130, 235, np.float64(8.660254037844387), 88],
 [131, 236, np.float64(8.660254037844387), 89],
 [46, 237, np.float64(8.717797887081348), 90],
 [16, 238, np.float64(8.774964387392123), 91],
 [79, 239, np.float64(8.774964387392123), 92],
 [137, 240, np.float64(8.888194417315589), 93],
 [128, 241, np.float64(8.94427190999916), 94],
 [57, 242, np.float64(9.1104335791443), 95],
 [40, 243, np.float64(9.16515138991168), 96],
 [60, 244, np.float64(9.219544457292887), 97],
 [45, 245, np.float64(9.273618495495704), 98],
 [95, 246, np.float64(9.327379053088816), 99],
 [132, 247, np.float64(9.327379053088816), 100],
 [0, 248, np.float64(9.38083151964686), 101],
 [126, 249, np.float64(9.433981132056603), 102],
 [134, 250, np.float64(9.433981132056603), 103],
 [101, 251, np.float64(9.486832980505138), 104],
 [15, 252, np.float64(9.539392014169456), 105],
 [96, 253, np.float64(9.695359714832659), 106],
 [22, 254, np.float64(9.746794344808963), 107],
 [26, 255, np.float64(9.746794344808963), 108],
 [74, 256, np.float64(9.848857801796104), 109],
 [64, 257, np.float64(9.899494936611665), 110],
 [7, 258, np.float64(9.9498743710662), 111],
 [30, 259, np.float64(9.9498743710662), 112],
 [72, 260, np.float64(10.04987562112089), 113],
 [105, 261, np.float64(10.198039027185569), 114],
 [139, 262, np.float64(10.295630140987), 115],
 [42, 263, np.float64(10.488088481701515), 116],
 [86, 264, np.float64(10.488088481701515), 117],
 [70, 265, np.float64(10.535653752852738), 118],
 [120, 266, np.float64(10.583005244258363), 119],
 [54, 267, np.float64(10.908712114635714), 120],
 [118, 268, np.float64(11.090536506409418), 121],
 [24, 269, np.float64(11.180339887498949), 122],
 [94, 270, np.float64(11.445523142259598), 123],
 [48, 271, np.float64(11.575836902790225), 124],
 [29, 272, np.float64(11.661903789690601), 125],
 [109, 273, np.float64(11.661903789690601), 126],
 [28, 274, np.float64(11.704699910719626), 127],
 [89, 275, np.float64(11.704699910719626), 128],
 [2, 276, np.float64(11.832159566199232), 129],
 [56, 277, np.float64(12.449899597988733), 130],
 [38, 278, np.float64(12.489995996796797), 131],
 [19, 279, np.float64(12.609520212918492), 132],
 [61, 280, np.float64(12.68857754044952), 133],
 [121, 281, np.float64(12.84523257866513), 134],
 [59, 282, np.float64(12.922847983320086), 135],
 [93, 283, np.float64(12.922847983320086), 136],
 [136, 284, np.float64(13.564659966250536), 137],
 [75, 285, np.float64(13.601470508735444), 138],
 [113, 286, np.float64(13.601470508735444), 139],
 [110, 287, np.float64(13.674794331177344), 140],
 [141, 288, np.float64(13.856406460551018), 141],
 [119, 289, np.float64(13.892443989449804), 142],
 [20, 290, np.float64(14.560219778561036), 143],
 [63, 291, np.float64(15.165750888103101), 144],
 [18, 292, np.float64(18.083141320025124), 145],
 [87, 293, np.float64(18.110770276274835), 146],
 [91, 294, np.float64(18.33030277982336), 147],
 [12, 295, np.float64(23.0), 148],
 [112, 296, np.float64(23.065125189341593), 149],
 [44, 297, np.float64(26.570660511172846), 150]]

# Prendre tous les textes
texts = newsgroups_df_neitoie['messages']

# Ne pas limiter la taille du vocabulaire (peut avoir beaucoup de dimensions)
vectorizer = CountVectorizer(binary=True)
X_sparse = vectorizer.fit_transform(texts)  # Le résultat est une matrice creuse

# Ici, il faut absolument convertir en dense pour faire l'ACP
X_dense = X_sparse.toarray()

# ACP pour réduire à deux dimensions
X_pca = PCA(n_components=2).fit_transform(X_dense)

# Convertir en DataFrame pour la visualisation
X_df = pd.DataFrame(X_pca, columns=["PC1", "PC2"])

# Définition des paramètres
K = 5            # Nombre de clusters
epsilon = 1e-4   # Seuil de convergence
iter_max = 50    # Nombre maximum d'itérations

# Exécution de l’algorithme k-means
centroids, affectation = clust.kmoyennes(K, X_df, epsilon, iter_max)
clust.affiche_resultat(X_df, centroids, affectation)

Iteration 1 Inertie : 46403.0196 Difference: 46402.0195
Iteration 2 Inertie : 39415.0931 Difference: 6987.9265
Iteration 3 Inertie : 35396.8007 Difference: 4018.2924
Iteration 4 Inertie : 32709.2515 Difference: 2687.5492
Iteration 5 Inertie : 30796.1320 Difference: 1913.1195
Iteration 6 Inertie : 29434.1439 Difference: 1361.9881
Iteration 7 Inertie : 28252.3214 Difference: 1181.8225
Iteration 8 Inertie : 27136.2536 Difference: 1116.0679
Iteration 9 Inertie : 26075.2361 Difference: 1061.0174
Iteration 10 Inertie : 25061.4848 Difference: 1013.7513
Iteration 11 Inertie : 24212.7577 Difference: 848.7271
Iteration 12 Inertie : 23615.9200 Difference: 596.8377
Iteration 13 Inertie : 23094.4398 Difference: 521.4802
Iteration 14 Inertie : 22589.7039 Difference: 504.7359
Iteration 15 Inertie : 22034.8734 Difference: 554.8305
Iteration 16 Inertie : 21549.7585 Difference: 485.1149
Iteration 17 Inertie : 21180.6042 Difference: 369.1543
Iteration 18 Inertie : 20858.2281 Difference: 322.3761
Iteration 19 Inertie : 20599.0363 Difference: 259.1917
Iteration 20 Inertie : 20403.3282 Difference: 195.7081
Iteration 21 Inertie : 20212.9472 Difference: 190.3810
Iteration 22 Inertie : 20036.0589 Difference: 176.8882
Iteration 23 Inertie : 19870.5194 Difference: 165.5395
Iteration 24 Inertie : 19742.1745 Difference: 128.3448
Iteration 25 Inertie : 19672.7197 Difference: 69.4548
Iteration 26 Inertie : 19610.7459 Difference: 61.9738
Iteration 27 Inertie : 19548.1759 Difference: 62.5700
Iteration 28 Inertie : 19508.2479 Difference: 39.9280
Iteration 29 Inertie : 19482.1350 Difference: 26.1129
Iteration 30 Inertie : 19458.5418 Difference: 23.5932
Iteration 31 Inertie : 19442.3436 Difference: 16.1982
Iteration 32 Inertie : 19430.7375 Difference: 11.6061
Iteration 33 Inertie : 19422.0440 Difference: 8.6935
Iteration 34 Inertie : 19414.0890 Difference: 7.9550
Iteration 35 Inertie : 19408.4960 Difference: 5.5930
Iteration 36 Inertie : 19402.8801 Difference: 5.6159
Iteration 37 Inertie : 19397.9217 Difference: 4.9583
Iteration 38 Inertie : 19393.6655 Difference: 4.2563
Iteration 39 Inertie : 19388.9800 Difference: 4.6855
Iteration 40 Inertie : 19386.1392 Difference: 2.8408
Iteration 41 Inertie : 19384.1877 Difference: 1.9515
Iteration 42 Inertie : 19383.1464 Difference: 1.0413
Iteration 43 Inertie : 19382.0251 Difference: 1.1213
Iteration 44 Inertie : 19381.0180 Difference: 1.0071
Iteration 45 Inertie : 19380.2422 Difference: 0.7759
Iteration 46 Inertie : 19379.7329 Difference: 0.5093
Iteration 47 Inertie : 19379.1265 Difference: 0.6064
Iteration 48 Inertie : 19378.7395 Difference: 0.3870
Iteration 49 Inertie : 19378.4130 Difference: 0.3265
Iteration 50 Inertie : 19378.0378 Difference: 0.3752

# Restaurer l'identifiant de cluster pour chaque échantillon sous forme de tableau
labels = np.zeros(len(X_df))
for cluster_id, indices in affectation.items():
    labels[indices] = cluster_id

# Calcul du score de silhouette
score = silhouette_score(X_df.values, labels)
print(f"Score de silhouette : {score:.4f}")

Score de silhouette : 0.4846

X_np = X_df.to_numpy()
labels = labels.astype(int)
xb = ev.xie_beni_index_manual(X_np, labels, centroids)
dunn = ev.dunn_index_manual(X_np, labels)

print(f"Xie-Beni Index (manual): {xb:.4f}")
print(f"Dunn Index (manual): {dunn:.4f}")

Xie-Beni Index (manual): 0.3101
Dunn Index (manual): 0.0001

y_true = newsgroups_df_neitoie['target'].values
labels_small = labels         # labels doit déjà contenir 1000 éléments

# Comparaison
ari = adjusted_rand_score(y_true, labels_small)
nmi = normalized_mutual_info_score(y_true, labels_small)

print(f"Indice de Rand Ajusté (ARI) : {ari:.4f}")
print(f"Information Mutuelle Normalisée (NMI) : {nmi:.4f}")

Indice de Rand Ajusté (ARI) : 0.0064
Information Mutuelle Normalisée (NMI) : 0.0242

# Définition des paramètres
K = 10            # Nombre de clusters
epsilon = 1e-4   # Seuil de convergence
iter_max = 50    # Nombre maximum d'itérations

# Exécution de l’algorithme k-means
centroids, affectation = clust.kmoyennes(K, X_df, epsilon, iter_max)
clust.affiche_resultat(X_df, centroids, affectation)

Iteration 1 Inertie : 55577.3123 Difference: 55576.3122
Iteration 2 Inertie : 43883.8869 Difference: 11693.4253
Iteration 3 Inertie : 37393.1439 Difference: 6490.7431
Iteration 4 Inertie : 33005.3924 Difference: 4387.7514
Iteration 5 Inertie : 28830.9562 Difference: 4174.4362
Iteration 6 Inertie : 20159.4831 Difference: 8671.4731
Iteration 7 Inertie : 15741.6647 Difference: 4417.8184
Iteration 8 Inertie : 14822.3822 Difference: 919.2825
Iteration 9 Inertie : 14283.3197 Difference: 539.0625
Iteration 10 Inertie : 13835.0995 Difference: 448.2202
Iteration 11 Inertie : 13470.6912 Difference: 364.4083
Iteration 12 Inertie : 13150.6046 Difference: 320.0866
Iteration 13 Inertie : 12901.8988 Difference: 248.7058
Iteration 14 Inertie : 12705.3962 Difference: 196.5025
Iteration 15 Inertie : 12526.0723 Difference: 179.3240
Iteration 16 Inertie : 12372.7408 Difference: 153.3314
Iteration 17 Inertie : 12234.2950 Difference: 138.4459
Iteration 18 Inertie : 12101.3767 Difference: 132.9183
Iteration 19 Inertie : 11973.2624 Difference: 128.1143
Iteration 20 Inertie : 11844.0723 Difference: 129.1901
Iteration 21 Inertie : 11725.9622 Difference: 118.1101
Iteration 22 Inertie : 11625.2652 Difference: 100.6970
Iteration 23 Inertie : 11517.0740 Difference: 108.1912
Iteration 24 Inertie : 11429.0055 Difference: 88.0684
Iteration 25 Inertie : 11341.3656 Difference: 87.6399
Iteration 26 Inertie : 11263.5221 Difference: 77.8435
Iteration 27 Inertie : 11186.5900 Difference: 76.9321
Iteration 28 Inertie : 11104.0295 Difference: 82.5605
Iteration 29 Inertie : 11018.5380 Difference: 85.4916
Iteration 30 Inertie : 10924.8554 Difference: 93.6826
Iteration 31 Inertie : 10789.4997 Difference: 135.3556
Iteration 32 Inertie : 10652.2133 Difference: 137.2865
Iteration 33 Inertie : 10536.6054 Difference: 115.6079
Iteration 34 Inertie : 10448.5441 Difference: 88.0613
Iteration 35 Inertie : 10379.3456 Difference: 69.1985
Iteration 36 Inertie : 10318.1563 Difference: 61.1893
Iteration 37 Inertie : 10266.6606 Difference: 51.4957
Iteration 38 Inertie : 10209.2166 Difference: 57.4440
Iteration 39 Inertie : 10158.2428 Difference: 50.9738
Iteration 40 Inertie : 10113.8277 Difference: 44.4152
Iteration 41 Inertie : 10081.0289 Difference: 32.7988
Iteration 42 Inertie : 10049.4325 Difference: 31.5964
Iteration 43 Inertie : 10020.2988 Difference: 29.1337
Iteration 44 Inertie : 9992.7377 Difference: 27.5611
Iteration 45 Inertie : 9963.4979 Difference: 29.2398
Iteration 46 Inertie : 9940.9922 Difference: 22.5057
Iteration 47 Inertie : 9918.3313 Difference: 22.6609
Iteration 48 Inertie : 9897.2770 Difference: 21.0542
Iteration 49 Inertie : 9877.3675 Difference: 19.9095
Iteration 50 Inertie : 9858.7481 Difference: 18.6194

# Restaurer l'identifiant de cluster pour chaque échantillon sous forme de tableau
labels = np.zeros(len(X_df))
for cluster_id, indices in affectation.items():
    labels[indices] = cluster_id

# Calcul du score de silhouette
score = silhouette_score(X_df.values, labels)
print(f"Score de silhouette : {score:.4f}")

Score de silhouette : 0.4010

X_np = X_df.to_numpy()
labels = labels.astype(int)
xb = ev.xie_beni_index_manual(X_np, labels, centroids)
dunn = ev.dunn_index_manual(X_np, labels)

print(f"Xie-Beni Index (manual): {xb:.4f}")
print(f"Dunn Index (manual): {dunn:.4f}")

Xie-Beni Index (manual): 0.7242
Dunn Index (manual): 0.0000

y_true = newsgroups_df_neitoie['target'].values
labels_small = labels         # labels doit déjà contenir 1000 éléments

# Comparaison
ari = adjusted_rand_score(y_true, labels_small)
nmi = normalized_mutual_info_score(y_true, labels_small)

print(f"Indice de Rand Ajusté (ARI) : {ari:.4f}")
print(f"Information Mutuelle Normalisée (NMI) : {nmi:.4f}")

Indice de Rand Ajusté (ARI) : 0.0065
Information Mutuelle Normalisée (NMI) : 0.0272

# Définition des paramètres
K = 20           # Nombre de clusters
epsilon = 1e-4   # Seuil de convergence
iter_max = 50    # Nombre maximum d'itérations

# Exécution de l’algorithme k-means
centroids, affectation = clust.kmoyennes(K, X_df, epsilon, iter_max)
clust.affiche_resultat(X_df, centroids, affectation)

Iteration 1 Inertie : 27268.6384 Difference: 27267.6383
Iteration 2 Inertie : 15995.3680 Difference: 11273.2704
Iteration 3 Inertie : 12129.4853 Difference: 3865.8827
Iteration 4 Inertie : 10412.0267 Difference: 1717.4586
Iteration 5 Inertie : 9309.5711 Difference: 1102.4556
Iteration 6 Inertie : 8709.7739 Difference: 599.7972
Iteration 7 Inertie : 8370.7626 Difference: 339.0113
Iteration 8 Inertie : 8121.1686 Difference: 249.5939
Iteration 9 Inertie : 7883.7018 Difference: 237.4669
Iteration 10 Inertie : 7679.6191 Difference: 204.0827
Iteration 11 Inertie : 7529.8441 Difference: 149.7750
Iteration 12 Inertie : 7412.1114 Difference: 117.7326
Iteration 13 Inertie : 7259.3056 Difference: 152.8058
Iteration 14 Inertie : 7163.7822 Difference: 95.5234
Iteration 15 Inertie : 7079.1300 Difference: 84.6522
Iteration 16 Inertie : 6971.2163 Difference: 107.9137
Iteration 17 Inertie : 6874.1317 Difference: 97.0846
Iteration 18 Inertie : 6788.2702 Difference: 85.8614
Iteration 19 Inertie : 6723.6032 Difference: 64.6671
Iteration 20 Inertie : 6676.2142 Difference: 47.3890
Iteration 21 Inertie : 6632.0965 Difference: 44.1177
Iteration 22 Inertie : 6583.2953 Difference: 48.8012
Iteration 23 Inertie : 6517.0966 Difference: 66.1988
Iteration 24 Inertie : 6468.9764 Difference: 48.1202
Iteration 25 Inertie : 6420.5834 Difference: 48.3929
Iteration 26 Inertie : 6360.8335 Difference: 59.7500
Iteration 27 Inertie : 6294.8602 Difference: 65.9733
Iteration 28 Inertie : 6221.9922 Difference: 72.8680
Iteration 29 Inertie : 6121.3740 Difference: 100.6182
Iteration 30 Inertie : 6017.5421 Difference: 103.8318
Iteration 31 Inertie : 5909.1630 Difference: 108.3792
Iteration 32 Inertie : 5798.9171 Difference: 110.2459
Iteration 33 Inertie : 5705.9492 Difference: 92.9679
Iteration 34 Inertie : 5633.3364 Difference: 72.6128
Iteration 35 Inertie : 5568.9276 Difference: 64.4088
Iteration 36 Inertie : 5510.6744 Difference: 58.2532
Iteration 37 Inertie : 5463.3961 Difference: 47.2783
Iteration 38 Inertie : 5423.2500 Difference: 40.1461
Iteration 39 Inertie : 5387.0285 Difference: 36.2215
Iteration 40 Inertie : 5354.6471 Difference: 32.3814
Iteration 41 Inertie : 5323.0041 Difference: 31.6430
Iteration 42 Inertie : 5296.4243 Difference: 26.5798
Iteration 43 Inertie : 5274.3916 Difference: 22.0326
Iteration 44 Inertie : 5253.7765 Difference: 20.6152
Iteration 45 Inertie : 5240.3153 Difference: 13.4612
Iteration 46 Inertie : 5228.3164 Difference: 11.9989
Iteration 47 Inertie : 5217.9474 Difference: 10.3689
Iteration 48 Inertie : 5207.8680 Difference: 10.0795
Iteration 49 Inertie : 5198.6711 Difference: 9.1969
Iteration 50 Inertie : 5189.6008 Difference: 9.0703

# Restaurer l'identifiant de cluster pour chaque échantillon sous forme de tableau
labels = np.zeros(len(X_df))
for cluster_id, indices in affectation.items():
    labels[indices] = cluster_id

# Calcul du score de silhouette
score = silhouette_score(X_df.values, labels)
print(f"Score de silhouette : {score:.4f}")

Score de silhouette : 0.3523

X_np = X_df.to_numpy()
labels = labels.astype(int)
xb = ev.xie_beni_index_manual(X_np, labels, centroids)
dunn = ev.dunn_index_manual(X_np, labels)

print(f"Xie-Beni Index (manual): {xb:.4f}")
print(f"Dunn Index (manual): {dunn:.4f}")

Xie-Beni Index (manual): 1.2682
Dunn Index (manual): 0.0001

y_true = newsgroups_df_neitoie['target'].values
labels_small = labels         # labels doit déjà contenir 1000 éléments

# Comparaison
ari = adjusted_rand_score(y_true, labels_small)
nmi = normalized_mutual_info_score(y_true, labels_small)

print(f"Indice de Rand Ajusté (ARI) : {ari:.4f}")
print(f"Information Mutuelle Normalisée (NMI) : {nmi:.4f}")

Indice de Rand Ajusté (ARI) : 0.0063
Information Mutuelle Normalisée (NMI) : 0.0342

	messages	target
0	\n\nI am sure some bashers of Pens fans are pr...	10
1	My brother is in the market for a high-perform...	3
2	\n\n\n\n\tFinally you said what you dream abou...	17
3	\nThink!\n\nIt's the SCSI card doing the DMA t...	3
4	1) I have an old Jasmine drive which I cann...	4
...	...	...
18841	DN> From: nyeda@cnsvax.uwec.edu (David Nye)\nD...	13
18842	\nNot in isolated ground recepticles (usually ...	12
18843	I just installed a DX2-66 CPU in a clone mothe...	3
18844	\nWouldn't this require a hyper-sphere. In 3-...	1
18845	After a tip from Gary Crum (crum@fcom.cc.utah....	7

	messages	target	les_mots
0	\n\nI am sure some bashers of Pens fans are pr...	10	[sure, bashers, pens, fans, pretty, confused, ...
1	My brother is in the market for a high-perform...	3	[brother, market, high, performance, video, ca...
2	\n\n\n\n\tFinally you said what you dream abou...	17	[finally, said, dream, mediterranean, new, are...
3	\nThink!\n\nIt's the SCSI card doing the DMA t...	3	[think, scsi, card, dma, transfers, disks, scs...
4	1) I have an old Jasmine drive which I cann...	4	[old, jasmine, drive, cannot, use, new, system...
...	...	...	...
18841	DN> From: nyeda@cnsvax.uwec.edu (David Nye)\nD...	13	[dn, nyeda, cnsvax, uwec, edu, david, nye, dn,...
18842	\nNot in isolated ground recepticles (usually ...	12	[isolated, ground, recepticles, usually, unusu...
18843	I just installed a DX2-66 CPU in a clone mothe...	3	[installed, cpu, clone, motherboard, tried, mo...
18844	\nWouldn't this require a hyper-sphere. In 3-...	1	[require, hyper, sphere, space, points, specif...
18845	After a tip from Gary Crum (crum@fcom.cc.utah....	7	[tip, gary, crum, crum, fcom, cc, utah, edu, g...

IA & Data science (LU3IN0226) -- 2024-2025¶

Mini-projet final¶

Projet 2 - avril-mai 2025¶

Travail à faire¶

Compte-rendu demandé¶

Soutenance des projets¶

Données pour le projet : 20newsgroups¶

Chargement des données¶

Prétraitement¶

Apprentissage supervisé¶

Tâches à réaliser¶

Classifier Perceptron¶

Classifier PerceptronBiais¶

Classifier KNN avec distance euclidienne¶

Classifier KNN avec distance cosinus¶

Classifier Naive Bayes¶

Classifier Arbre de decision¶

Apprentissage non-supervisé¶

Clustering hiérarchique¶

k-moyennes¶

Poster à rendre dans le compte-rendu (format PDF)¶

	stopword
0	a
1	about
2	above
3	after
4	again
...	...
193	you're
194	yours
195	yourself
196	yourselves
197	you've

	abandon	abandoned	abbey	abbreviation	abdomen	abdominal	abduct	aberrant	aberration	abhor	...	zeta	zinc	zip	zipper	zippy	zodiacal	zone	zoo	zooid	zoom
0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
1	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
2	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
3	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
4	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
18461	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
18462	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
18463	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
18464	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
18465	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0